diff --git a/decompiler/analysis/variable_naming.cpp b/decompiler/analysis/variable_naming.cpp
index 1ac858e51d..9c11f9bcdd 100644
--- a/decompiler/analysis/variable_naming.cpp
+++ b/decompiler/analysis/variable_naming.cpp
@@ -737,7 +737,9 @@ void SSA::make_vars(const Function& function, const DecompilerTypeSystem& dts) {
                          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 crimson-guard-level)";
+                         function.guessed_name.to_string() == "(method 74 crimson-guard-level)" ||
+                         function.guessed_name.to_string() == "widow-handler" ||
+                         function.guessed_name.to_string() == "(method 74 hal)";
   }
 
   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 4399758766..681d9898e9 100644
--- a/decompiler/config/jak2/all-types.gc
+++ b/decompiler/config/jak2/all-types.gc
@@ -15611,6 +15611,7 @@
    (damp-period float   :offset-assert 24)
    (ticks       float   :offset-assert 28)
    )
+  :pack-me
   :method-count-assert 15
   :size-assert         #x20
   :flag-assert         #xf00000020
@@ -32421,6 +32422,7 @@
 (defenum enemy-aware
   :type uint64
   (enemy-aware-0 0)
+  (enemy-aware-1 1)
   (enemy-aware-2 2)
   (enemy-aware-3 3)
   (enemy-aware-4 4)
@@ -34862,7 +34864,6 @@
 ;; spyder                         ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype spyder-shot (metalhead-shot)
   ()
   :method-count-assert 40
@@ -34871,26 +34872,24 @@
   (:methods
     )
   )
-|#
 
-#|
 (deftype spyder (nav-enemy)
-  ((los               los-control :inline :offset-assert 604)
-   (joint             basic               :offset-assert 752)
-   (start-pos         vector      :inline :offset-assert 764)
-   (focus-pos         vector      :inline :offset-assert 348)
-   (face-pos          vector      :inline :offset-assert 796)
-   (my-up-vector      vector      :inline :offset-assert 812)
-   (status-flags      uint64              :offset-assert 828)
-   (change-dir-timer  uint64              :offset-assert 836)
-   (fire-info         UNKNOWN     2       :offset-assert 844)
-   (joint-ik          UNKNOWN     4       :offset-assert 876)
-   (delta-y-ik        UNKNOWN     4       :offset-assert 892)
-   (predator-effect?  basic               :offset-assert 908)
-   (shock-effect-time time-frame              :offset-assert 916)
-   (shock-effect-end  uint64              :offset-assert 924)
-   (fade              float               :offset-assert 932)
-   (dest-fade         float               :offset-assert 936)
+  ((los               los-control :inline :offset-assert 608)
+   (joint             joint-mod           :offset-assert 756)
+   (start-pos         vector      :inline :offset-assert 768)
+   ;; (focus-pos         vector      :inline :offset 348)
+   (face-pos          vector      :inline :offset 800)
+   (my-up-vector      vector      :inline :offset-assert 816)
+   (status-flags      uint64              :offset-assert 832)
+   (change-dir-timer  time-frame          :offset-assert 840)
+   (fire-info         vector 2    :inline :offset-assert 848)
+   (joint-ik          joint-mod-ik 4      :offset 880)
+   (delta-y-ik        float 4             :offset-assert 896)
+   (predator-effect?  symbol              :offset-assert 912)
+   (shock-effect-time time-frame          :offset-assert 920)
+   (shock-effect-end  time-frame          :offset-assert 928)
+   (fade              float               :offset-assert 936)
+   (dest-fade         float               :offset-assert 940)
    )
   :method-count-assert 186
   :size-assert         #x3b0
@@ -34898,17 +34897,15 @@
   (:methods
     (attack () _type_ :state 178)
     (backup () _type_ :state 179)
-    (spyder-method-180 () none 180)
-    (spyder-method-181 () none 181)
-    (spyder-method-182 () none 182)
-    (spyder-method-183 () none 183)
-    (spyder-method-184 () none 184)
-    (spyder-method-185 () none 185)
+    (spyder-method-180 (_type_) none 180)
+    (spyder-method-181 (_type_) none 181)
+    (spyder-method-182 (_type_) none 182)
+    (spyder-method-183 (_type_ matrix float) none 183) ;; arg0 guess
+    (spyder-method-184 (_type_ vector) none 184)
+    (spyder-method-185 (_type_) none 185)
     )
   )
-|#
 
-#|
 (deftype ik-setup (structure)
   ((elbow-index int32  :offset-assert 0)
    (hand-dist   float  :offset-assert 4)
@@ -34917,12 +34914,11 @@
   :size-assert         #x8
   :flag-assert         #x900000008
   )
-|#
 
-;; (define-extern *spyder-nav-enemy-info* nav-enemy-info)
-;; (define-extern spyder-travel-post function)
-;; (define-extern spyder-face-player-post function)
-;; (define-extern *spyder-ik-setup* object)
+(define-extern *spyder-nav-enemy-info* nav-enemy-info)
+(define-extern spyder-travel-post (function none :behavior spyder))
+(define-extern spyder-face-player-post (function none :behavior spyder))
+(define-extern *spyder-ik-setup* (inline-array ik-setup))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; crimson-guard-level            ;;
@@ -36592,7 +36588,7 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (deftype dig-spikey-step (process-drawable)
-  ((smush         smush-control :inline :offset-assert 208)
+  ((smush         smush-control :inline :offset-assert 200)
    (init-quat     quaternion    :inline :offset-assert 240)
    (shudder-angle float                 :offset-assert 256)
    (rot-angle     float                 :offset-assert 260)
@@ -37818,7 +37814,7 @@
    (blade-angle         float                    :offset-assert 632)
    (desired-distance    float                    :offset-assert 636)
    (spiral-time         time-frame               :offset-assert 640)
-   (blade-part          part-spawner             :offset-assert 648)
+   (blade-part          sparticle-launch-control :offset-assert 648)
    (ambush-path         path-control             :offset-assert 652)
    (path-pos            float                    :offset-assert 656)
    (ambush-started      symbol                   :offset-assert 660)
@@ -39418,10 +39414,9 @@
 ;; atoll-tank                     ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype atoll-tank (process-focusable)
-  ((is-master?     basic  :offset-assert 200)
-   (aftermath-part basic  :offset-assert 204)
+  ((is-master?     symbol :offset-assert 204)
+   (aftermath-part sparticle-launch-control  :offset-assert 208)
    )
   :method-count-assert 29
   :size-assert         #xd4
@@ -39431,9 +39426,8 @@
     (idle () _type_ :state 28)
     )
   )
-|#
 
-;; (define-extern atoll-tank-init-by-other function)
+(define-extern atoll-tank-init-by-other (function process-drawable int none :behavior atoll-tank))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; atoll-scenes                   ;;
@@ -39445,9 +39439,8 @@
 ;; sniper                         ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype sniper (spyder)
-  ((next-pick-time time-frame  :offset-assert 940)
+  ((next-pick-time time-frame  :offset-assert 944)
    )
   :method-count-assert 186
   :size-assert         #x3b8
@@ -39455,9 +39448,8 @@
   (:methods
     )
   )
-|#
 
-;; (define-extern *sniper-nav-enemy-info* nav-enemy-info)
+(define-extern *sniper-nav-enemy-info* nav-enemy-info)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; amphibian                      ;;
@@ -39557,10 +39549,9 @@
 ;; juicer                         ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype juicer-shot (projectile)
-  ((lightning UNKNOWN 5 :offset-assert 468)
-   (victim    uint64    :offset-assert 492)
+  ((lightning lightning-control 5 :offset-assert 472)
+   (victim    handle              :offset-assert 496)
    )
   :method-count-assert 40
   :size-assert         #x1f8
@@ -39568,9 +39559,7 @@
   (:methods
     )
   )
-|#
 
-#|
 (deftype juicer-anim-info (structure)
   ((anim-index int32  :offset-assert 0)
    )
@@ -39578,46 +39567,42 @@
   :size-assert         #x4
   :flag-assert         #x900000004
   )
-|#
 
-#|
 (deftype juicer-global-info (basic)
   ((prev-yellow-hit int8      :offset-assert 4)
    (prev-blue-hit   int8      :offset-assert 5)
-   (idle-anim       UNKNOWN 3 :offset-assert 8)
-   (patrol-anim     UNKNOWN 2 :offset-assert 20)
-   (notice-anim     UNKNOWN 2 :offset-assert 28)
-   (charge-anim     UNKNOWN 2 :offset-assert 36)
-   (knocked-anim    UNKNOWN 2 :offset-assert 44)
-   (celebrate-anim  UNKNOWN 2 :offset-assert 52)
-   (yellow-hit-anim UNKNOWN 4 :offset-assert 60)
-   (blue-hit-anim   UNKNOWN 6 :offset-assert 76)
+   (idle-anim       int32 3   :offset-assert 8)
+   (patrol-anim     int32 2   :offset-assert 20)
+   (notice-anim     int32 2   :offset-assert 28)
+   (charge-anim     int32 2   :offset-assert 36)
+   (knocked-anim    int32 2   :offset-assert 44)
+   (celebrate-anim  int32 2   :offset-assert 52)
+   (yellow-hit-anim int32 4   :offset-assert 60)
+   (blue-hit-anim   int32 6   :offset-assert 76)
    )
   :method-count-assert 9
   :size-assert         #x64
   :flag-assert         #x900000064
   )
-|#
 
-#|
 (deftype juicer (nav-enemy)
-  ((los                los-control :inline :offset-assert 604)
-   (intro-path         basic               :offset-assert 752)
-   (joint              basic               :offset-assert 756)
-   (joint-enable       basic               :offset-assert 760)
-   (joint-blend        float               :offset-assert 764)
-   (last-fire-time     time-frame              :offset-assert 772)
-   (heading            basic               :offset-assert 780)
-   (move-angle         float               :offset-assert 784)
-   (torso-track-player basic               :offset-assert 788)
-   (circle-backward?   basic               :offset-assert 796)
-   (using-turn-anim    basic               :offset-assert 800)
-   (hit-focus          basic               :offset-assert 804)
-   (ambush-path-pt     int8                :offset-assert 808)
-   (charge-index       int8                :offset-assert 809)
-   (hostile-dest       vector      :inline :offset-assert 812)
-   (focus-is-up        basic               :offset-assert 828)
-   (current-projectile uint64              :offset-assert 836)
+  ((los                los-control :inline :offset-assert 608)
+   (intro-path         path-control        :offset-assert 756)
+   (joint              joint-mod           :offset-assert 760)
+   (joint-enable       symbol              :offset-assert 764)
+   (joint-blend        float               :offset-assert 768)
+   (last-fire-time     time-frame          :offset-assert 776)
+   (heading            basic               :offset-assert 784)
+   (move-angle         float               :offset-assert 788)
+   (torso-track-player basic               :offset-assert 792)
+   (circle-backward?   symbol              :offset 800)
+   (using-turn-anim    symbol              :offset-assert 804)
+   (hit-focus          enemy-focus         :offset-assert 808)
+   (ambush-path-pt     int8                :offset-assert 812)
+   (charge-index       int8                :offset-assert 813)
+   (hostile-dest       vector      :inline :offset-assert 816)
+   (focus-is-up        symbol              :offset-assert 832)
+   (current-projectile handle              :offset-assert 840)
    )
   :method-count-assert 185
   :size-assert         #x350
@@ -39625,19 +39610,18 @@
   (:methods
     (ambush-cont () _type_ :state 178)
     (attack () _type_ :state 179)
-    (juicer-method-180 () none 180)
-    (juicer-method-181 () none 181)
-    (juicer-method-182 () none 182)
-    (juicer-method-183 () none 183)
-    (juicer-method-184 () none 184)
+    (juicer-method-180 (_type_) none 180)
+    (fire-projectile (_type_ process-focusable uint) none 181)
+    (juicer-method-182 (_type_) none 182)
+    (juicer-method-183 (_type_) none 183)
+    (juicer-method-184 (_type_ symbol) none 184)
     )
   )
-|#
 
-;; (define-extern juicer-proj-move function)
-;; (define-extern *juicer-global-info* juicer-global-info)
-;; (define-extern *juicer-nav-enemy-info* nav-enemy-info)
-;; (define-extern juicer-face-player-post function)
+(define-extern juicer-proj-move (function juicer-shot none :behavior juicer))
+(define-extern *juicer-global-info* juicer-global-info)
+(define-extern *juicer-nav-enemy-info* nav-enemy-info)
+(define-extern juicer-face-player-post (function none :behavior juicer))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; ctyfarm-obs                    ;;
@@ -39810,10 +39794,9 @@
 ;; yakow                          ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype yakow (nav-enemy)
-  ((incoming-attack-id uint32  :offset-assert 600)
-   (grazing            basic   :offset-assert 604)
+  ((incoming-attack-id uint32  :offset-assert 604)
+   (grazing            basic   :offset-assert 608)
    )
   :method-count-assert 179
   :size-assert         #x264
@@ -39822,9 +39805,8 @@
     (kicked () _type_ :state 178)
     )
   )
-|#
 
-;; (define-extern *yakow-nav-enemy-info* nav-enemy-info)
+(define-extern *yakow-nav-enemy-info* nav-enemy-info)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; casboss-texture                ;;
@@ -40331,16 +40313,15 @@
 ;; atoll-obs                      ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype piston (process-focusable)
-  ((sound-trans  vector     :inline :offset-assert 204)
-   (init-height  float              :offset-assert 220)
-   (range-top    float              :offset-assert 224)
-   (range-bottom float              :offset-assert 228)
-   (sound-time   UNKNOWN    2       :offset-assert 236)
-   (sync         sync-eased :inline :offset-assert 252)
-   (piston-id    int32              :offset-assert 296)
-   (looping-id   uint32             :offset-assert 300)
+  ((sound-trans  vector     :inline :offset-assert 208)
+   (init-height  float              :offset-assert 224)
+   (range-top    float              :offset-assert 228)
+   (range-bottom float              :offset-assert 232)
+   (sound-time   time-frame 2       :offset-assert 240)
+   (sync         sync-eased :inline :offset-assert 256)
+   (piston-id    int32              :offset-assert 300)
+   (looping-id   uint32             :offset-assert 304)
    )
   :method-count-assert 31
   :size-assert         #x134
@@ -40352,14 +40333,12 @@
     (running () _type_ :state 30)
     )
   )
-|#
 
-#|
 (deftype turbine (process-drawable)
-  ((dest-height float  :offset-assert 196)
-   (rise-height float  :offset-assert 200)
-   (rotspeed    float  :offset-assert 204)
-   (risen       basic  :offset-assert 208)
+  ((dest-height float  :offset-assert 200)
+   (rise-height float  :offset-assert 204)
+   (rotspeed    float  :offset-assert 208)
+   (risen       symbol :offset-assert 212)
    )
   :method-count-assert 22
   :size-assert         #xd8
@@ -40369,12 +40348,10 @@
     (risen () _type_ :state 21)
     )
   )
-|#
 
-#|
 (deftype liftcat (process-drawable)
-  ((up-y   float  :offset-assert 196)
-   (down-y float  :offset-assert 200)
+  ((up-y   float  :offset-assert 200)
+   (down-y float  :offset-assert 204)
    )
   :method-count-assert 23
   :size-assert         #xd0
@@ -40385,16 +40362,15 @@
     (idle-down () _type_ :state 22)
     )
   )
-|#
 
-#|
 (deftype atollrotpipe (process-drawable)
-  ((smush         smush-control :inline :offset-assert 196)
-   (init-quat     quaternion    :inline :offset-assert 236)
-   (rot-angle     float                 :offset-assert 252)
-   (shudder-angle float                 :offset-assert 256)
-   (cycle-time    float                 :offset-assert 260)
-   (cycle-offset  float                 :offset-assert 264)
+  ((root-override collide-shape-moving  :offset 128 :score 1)
+   (smush         smush-control :inline :offset 200)
+   (init-quat     quaternion    :inline :offset 240)
+   (rot-angle     float                 :offset 256)
+   (shudder-angle float                 :offset 260)
+   (cycle-time    float                 :offset 264)
+   (cycle-offset  float                 :offset 268)
    )
   :method-count-assert 21
   :size-assert         #x110
@@ -40403,17 +40379,16 @@
     (idle () _type_ :state 20)
     )
   )
-|#
 
-#|
 (deftype slider (process-drawable)
-  ((path-pos          float              :offset-assert 196)
-   (sync              sync-eased :inline :offset-assert 204)
-   (attack-id         uint32             :offset-assert 248)
-   (sound-id          uint32             :offset-assert 252)
-   (collide-off-timer uint64             :offset-assert 260)
-   (l-points          UNKNOWN    6       :offset-assert 268)
-   (l-bolts           UNKNOWN    4       :offset-assert 364)
+  ((root-override     collide-shape-moving :offset 128 :score 1)
+   (path-pos          float              :offset-assert 200)
+   (sync              sync-eased :inline :offset-assert 208)
+   (attack-id         uint32             :offset-assert 252)
+   (sound-id          uint32             :offset-assert 256)
+   (collide-off-timer uint64             :offset-assert 264)
+   (l-points          vector   6 :inline :offset-assert 272)
+   (l-bolts           lightning-control 4 :offset-assert 368)
    )
   :method-count-assert 21
   :size-assert         #x180
@@ -40422,13 +40397,11 @@
     (idle () _type_ :state 20)
     )
   )
-|#
 
-#|
 (deftype atoll-windmill (process-drawable)
-  ((sync         sync-linear :inline :offset-assert 196)
-   (blade-normal vector      :inline :offset-assert 220)
-   (orig-quat    quaternion  :inline :offset-assert 236)
+  ((sync         sync-linear :inline :offset-assert 200)
+   (blade-normal vector      :inline :offset-assert 224)
+   (orig-quat    quaternion  :inline :offset-assert 240)
    )
   :method-count-assert 21
   :size-assert         #x100
@@ -40437,9 +40410,7 @@
     (idle () _type_ :state 20)
     )
   )
-|#
 
-#|
 (deftype atoll-valve (process-drawable)
   ()
   :method-count-assert 21
@@ -40449,9 +40420,7 @@
     (idle () _type_ :state 20)
     )
   )
-|#
 
-#|
 (deftype atoll-hatch (process-drawable)
   ()
   :method-count-assert 21
@@ -40461,9 +40430,7 @@
     (idle () _type_ :state 20)
     )
   )
-|#
 
-#|
 (deftype atoll-hellcat (process-drawable)
   ()
   :method-count-assert 22
@@ -40474,9 +40441,7 @@
     (idle () _type_ :state 21)
     )
   )
-|#
 
-#|
 (deftype atoll-mar-symbol (process-drawable)
   ()
   :method-count-assert 21
@@ -40486,7 +40451,6 @@
     (idle () _type_ :state 20)
     )
   )
-|#
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -40545,22 +40509,22 @@
 
 (deftype hal (bot)
   ((handle-failed-slave-id int8      :offset-assert 992)
-   (slave-handle           uint64  3 :offset-assert 1000)
+   (slave-handle           handle  3 :offset-assert 1000)
    )
   :method-count-assert 227
   :size-assert         #x400
   :flag-assert         #xe303800400
   (:methods
-    (hal-method-225 () none 225)
-    (hal-method-226 () none 226)
+    (hal-method-225 (_type_) symbol 225)
+    (hal-method-226 (_type_) symbol 226)
     )
   )
 
 (deftype halt-wait-spot (ai-task)
-  ((check-done   basic     :offset 32)
-   (which-spot   int8      :offset 36)
-   (num-spots    uint8     :offset 37)
-   (spot-indexes int8    6 :offset 38)
+  ((check-done   (function halt-wait-spot hal symbol) :offset 32)
+   (which-spot   int8       :offset 36)
+   (num-spots    uint8      :offset 37)
+   (spot-indexes uint8    6 :offset 38)
    )
   :method-count-assert 12
   :size-assert         #x30
@@ -40579,10 +40543,10 @@
 ;; hal                            ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *hal-nav-enemy-info* nav-enemy-info)
-;; (define-extern hal-simple-check-too-far function)
-;; (define-extern hal-post function)
-;; (define-extern hal-event-handler function)
+(define-extern *hal-nav-enemy-info* nav-enemy-info)
+(define-extern hal-simple-check-too-far (function hal int))
+(define-extern hal-post (function none :behavior hal))
+(define-extern hal-event-handler (function process int symbol event-message-block object :behavior hal))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; ruf-h                          ;;
@@ -42120,32 +42084,40 @@
 ;; nest-obs                       ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
-(deftype nest-switch (UNKNOWN)
-  ()
-  :method-count-assert 0
-  :size-assert         #x0
-  :flag-assert         #x0
-  ;; Failed to read fields.
+(deftype nest-switch (process-drawable)
+  ((set-camera   symbol :offset-assert 200)
+   (notify-actor entity-actor :offset-assert 204)
+   (y-start      float  :offset-assert 208)
+   (y-delta      float  :offset-assert 212)
+   (y-rot-rate   float  :offset-assert 216)
+   )
+  :method-count-assert 22
+  :size-assert         #xdc
+  :flag-assert         #x16006000dc
+  (:methods
+   (up () _type_ :state 20)
+   (down () _type_ :state 21)
+   )
   )
-|#
 
-#|
-(deftype nest-piston (UNKNOWN)
-  ()
-  :method-count-assert 0
-  :size-assert         #x0
-  :flag-assert         #x0
-  ;; Failed to read fields.
+(deftype nest-piston (process-drawable)
+  ((y-level  float :offset-assert 200)
+   (y-offset float :offset-assert 204)
+   )
+  :method-count-assert 22
+  :size-assert         #xd0
+  :flag-assert         #x16005000d0
+  (:methods
+   (idle () _type_ :state 20)
+   (up () _type_ :state 21)
+   )
   )
-|#
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; mantis                         ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype mantis-jump-info (structure)
   ((distance    float          :offset-assert 0)
    (search-step uint32         :offset-assert 4)
@@ -42159,15 +42131,29 @@
   :size-assert         #x30
   :flag-assert         #x900000030
   )
-|#
 
-#|
+;; +++mantis:mantis-flag
+(defenum mantis-flag
+  :type uint16
+  :bitfield #t
+  (tracked 0)
+  (attack1-enabled 1)
+  )
+;; ---mantis:mantis-flag
+
 (deftype mantis (nav-enemy)
-  ()
+  ((base-height  float                    :offset-assert 604)
+   (flags        mantis-flag              :offset-assert 608)
+   (attack-timer time-frame               :offset-assert 616)
+   (track-timer  time-frame               :offset-assert 624)
+   (gspot-timer  time-frame               :offset-assert 632)
+   (gspot-normal vector           :inline :offset-assert 640)
+   (my-up-vector vector           :inline :offset-assert 656)
+   (jump         mantis-jump-info :inline :offset-assert 672)
+   )
   :method-count-assert 195
   :size-assert         #x2d0
   :flag-assert         #xc3025002d0
-  ;; Failed to read fields.
   (:methods
     (crawl () _type_ :state 178)
     (attack0 () _type_ :state 179)
@@ -42178,55 +42164,53 @@
     (roll-right () _type_ :state 184)
     (roll-left () _type_ :state 185)
     (hop-away () _type_ :state 186)
-    (mantis-method-187 () none 187)
-    (mantis-method-188 () none 188)
-    (mantis-method-189 () none 189)
-    (mantis-method-190 () none 190)
-    (mantis-method-191 () none 191)
-    (mantis-method-192 () none 192)
-    (mantis-method-193 () none 193)
-    (mantis-method-194 () none 194)
+    (mantis-method-187 (_type_) none 187)
+    (mantis-method-188 (_type_) none 188)
+    (mantis-method-189 (_type_ vector vector) symbol 189)
+    (mantis-method-190 (_type_ vector vector) none 190)
+    (mantis-method-191 (_type_ vector vector) int 191)
+    (mantis-method-192 (_type_ vector vector) none 192)
+    (mantis-method-193 (_type_ vector) none 193)
+    (mantis-method-194 (_type_) symbol 194)
     )
   )
-|#
 
-;; (define-extern *mantis-nav-enemy-info* nav-enemy-info)
+(define-extern *mantis-nav-enemy-info* nav-enemy-info)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; mammoth                        ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype mammoth (nav-enemy)
-  ((joint-ik               UNKNOWN    4       :offset-assert 600)
-   (ik-handle-pos          UNKNOWN    4       :offset-assert 620)
-   (ik-handle-y            UNKNOWN    4       :offset-assert 684)
-   (heel-lerp              UNKNOWN    4       :offset-assert 700)
-   (foot-flags             uint16             :offset-assert 716)
-   (old-foot-flags         uint16             :offset-assert 718)
-   (y-level                float              :offset-assert 720)
-   (foot-pos               UNKNOWN    4       :offset-assert 732)
-   (my-up-vector           vector     :inline :offset-assert 796)
-   (my-up-quat             quaternion :inline :offset-assert 812)
-   (move-pos               UNKNOWN    2       :offset-assert 828)
-   (travel-dest            vector     :inline :offset-assert 860)
-   (tilt-quat              quaternion :inline :offset-assert 876)
-   (path-index             int32              :offset-assert 892)
-   (path-index-dir         int32              :offset-assert 896)
-   (path-pos               float              :offset-assert 900)
-   (turn-angle             float              :offset-assert 904)
-   (gspot-timer            uint64             :offset-assert 908)
-   (gspot-normal           vector     :inline :offset-assert 924)
-   (attack-timer           uint64             :offset-assert 940)
-   (lightning-timer        uint64             :offset-assert 948)
-   (lightning-attack-timer uint64             :offset-assert 956)
-   (spawn-timer            uint64             :offset-assert 964)
-   (turn-anim-start        int32              :offset-assert 972)
-   (turn-anim              int32              :offset-assert 976)
-   (turn-anim-end          int32              :offset-assert 980)
-   (turn-move-start        float              :offset-assert 984)
-   (turn-move-end          float              :offset-assert 988)
-   (feet-ik-init-timer     uint64             :offset-assert 996)
+  ((joint-ik               joint-mod-ik 4     :offset-assert 604)
+   (ik-handle-pos          vector   4 :inline :offset-assert 624)
+   (ik-handle-y            float    4         :offset-assert 688)
+   (heel-lerp              float    4         :offset-assert 704)
+   (foot-flags             uint16             :offset-assert 720)
+   (old-foot-flags         uint16             :offset-assert 722)
+   (y-level                float              :offset-assert 724)
+   (foot-pos               vector   4 :inline :offset-assert 736)
+   (my-up-vector           vector     :inline :offset-assert 800)
+   (my-up-quat             quaternion :inline :offset-assert 816)
+   (move-pos               vector   2 :inline :offset-assert 832)
+   (travel-dest            vector     :inline :offset-assert 864)
+   (tilt-quat              quaternion :inline :offset-assert 880)
+   (path-index             int32              :offset-assert 896)
+   (path-index-dir         int32              :offset-assert 900)
+   (path-pos               float              :offset-assert 904)
+   (turn-angle             float              :offset-assert 908)
+   (gspot-timer            time-frame         :offset-assert 912)
+   (gspot-normal           vector     :inline :offset-assert 928)
+   (attack-timer           time-frame         :offset-assert 944)
+   (lightning-timer        time-frame         :offset-assert 952)
+   (lightning-attack-timer time-frame         :offset-assert 960)
+   (spawn-timer            time-frame         :offset-assert 968)
+   (turn-anim-start        int32              :offset-assert 976)
+   (turn-anim              int32              :offset-assert 980)
+   (turn-anim-end          int32              :offset-assert 984)
+   (turn-move-start        float              :offset-assert 988)
+   (turn-move-end          float              :offset-assert 992)
+   (feet-ik-init-timer     time-frame         :offset-assert 1000)
    )
   :method-count-assert 186
   :size-assert         #x3f0
@@ -42237,14 +42221,12 @@
     (walking () _type_ :state 180)
     (walking-attack () _type_ :state 181)
     (turning () _type_ :state 182)
-    (mammoth-method-183 () none 183)
-    (mammoth-method-184 () none 184)
-    (mammoth-method-185 () none 185)
+    (mammoth-method-183 (_type_) none 183)
+    (mammoth-method-184 (_type_) none 184)
+    (mammoth-method-185 (_type_ vector int) none 185)
     )
   )
-|#
 
-#|
 (deftype mammoth-ik-setup (structure)
   ((elbow-index int32   :offset-assert 0)
    (hand-dist   float   :offset-assert 4)
@@ -42255,26 +42237,24 @@
   :size-assert         #xe
   :flag-assert         #x90000000e
   )
-|#
 
-;; (define-extern *mammoth-nav-enemy-info* nav-enemy-info)
-;; (define-extern *mammoth-lightning-joint-tbl* array)
-;; (define-extern *mammoth-ik-setup* object)
-;; (define-extern mammoth-walk-post function)
-;; (define-extern mammoth-walk-check-end function)
-;; (define-extern next-path-index function)
-;; (define-extern set-nav-destination function)
-;; (define-extern mammoth-walk-handler function)
-;; (define-extern mammoth-joint-mod-tilt function)
-;; (define-extern mammoth-joint-mod-heel function)
-;; (define-extern mammoth-leg-ik-callback function)
-;; (define-extern mammoth-update-ik function)
+(define-extern *mammoth-nav-enemy-info* nav-enemy-info)
+(define-extern *mammoth-lightning-joint-tbl* (array int32))
+(define-extern *mammoth-ik-setup* (inline-array mammoth-ik-setup))
+(define-extern mammoth-walk-post (function none :behavior mammoth))
+(define-extern mammoth-walk-check-end (function none :behavior mammoth))
+(define-extern next-path-index (function none :behavior mammoth))
+(define-extern set-nav-destination (function none :behavior mammoth))
+(define-extern mammoth-walk-handler (function process int symbol event-message-block object :behavior mammoth))
+(define-extern mammoth-joint-mod-tilt (function cspace transformq none))
+(define-extern mammoth-joint-mod-heel (function cspace transformq none))
+(define-extern mammoth-leg-ik-callback (function joint-mod-ik matrix matrix vector object))
+(define-extern mammoth-update-ik (function none :behavior mammoth))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; flying-spider                  ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype flying-spider-shot (metalhead-shot)
   ()
   :method-count-assert 40
@@ -42283,16 +42263,14 @@
   (:methods
     )
   )
-|#
 
-#|
 (deftype flying-spider (nav-enemy)
-  ((my-up-vector vector :inline :offset-assert 604)
-   (gspot-normal vector :inline :offset-assert 620)
-   (gspot-timer  uint64         :offset-assert 636)
-   (focus-dir    uint16         :offset-assert 644)
-   (path-u       float          :offset-assert 648)
-   (path-du      float          :offset-assert 652)
+  ((my-up-vector vector :inline :offset-assert 608)
+   (gspot-normal vector :inline :offset-assert 624)
+   (gspot-timer  time-frame     :offset-assert 640)
+   (focus-dir    uint16         :offset-assert 648)
+   (path-u       float          :offset-assert 652)
+   (path-du      float          :offset-assert 656)
    )
   :method-count-assert 183
   :size-assert         #x294
@@ -42302,13 +42280,12 @@
     (attack () _type_ :state 179)
     (attack-fire () _type_ :state 180)
     (turn-to-focus () _type_ :state 181)
-    (flying-spider-method-182 () none 182)
+    (flying-spider-method-182 (_type_ vector) none 182)
     )
   )
-|#
 
-;; (define-extern spawn-flying-spider-projectile function)
-;; (define-extern *flying-spider-nav-enemy-info* nav-enemy-info)
+(define-extern spawn-flying-spider-projectile (function flying-spider vector vector float (pointer process)))
+(define-extern *flying-spider-nav-enemy-info* nav-enemy-info)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; nest-ocean                     ;;
@@ -44138,15 +44115,14 @@
 ;; spydroid                       ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype spydroid (nav-enemy)
-  ((old-y-deg    float     :offset-assert 600)
-   (diff-angle   float     :offset-assert 604)
-   (desire-turn  basic     :offset-assert 608)
-   (hit-target   basic     :offset-assert 612)
-   (lightning    UNKNOWN 4 :offset-assert 616)
-   (floor        float     :offset-assert 632)
-   (explode-part basic     :offset-assert 636)
+  ((old-y-deg    float                    :offset-assert 604)
+   (diff-angle   float                    :offset-assert 608)
+   (desire-turn  symbol                   :offset-assert 612)
+   (hit-target   basic                    :offset-assert 616)
+   (lightning    lightning-control 4      :offset-assert 620)
+   (floor        float                    :offset-assert 636)
+   (explode-part sparticle-launch-control :offset-assert 640)
    )
   :method-count-assert 179
   :size-assert         #x284
@@ -44155,10 +44131,9 @@
     (attack () _type_ :state 178)
     )
   )
-|#
 
-;; (define-extern *spydroid-exploder-params* joint-exploder-static-params)
-;; (define-extern *spydroid-nav-enemy-info* nav-enemy-info)
+(define-extern *spydroid-exploder-params* joint-exploder-static-params)
+(define-extern *spydroid-nav-enemy-info* nav-enemy-info)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; palent-part                    ;;
@@ -45847,7 +45822,6 @@
 ;; widow-baron                    ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype widow-float-seeker (structure)
   ((target      float  :offset-assert 0)
    (value       float  :offset-assert 4)
@@ -45857,19 +45831,18 @@
    (max-partial float  :offset-assert 20)
    (bounce-high float  :offset-assert 24)
    )
+  :allow-misaligned
   :method-count-assert 13
   :size-assert         #x1c
   :flag-assert         #xd0000001c
   (:methods
-    (widow-float-seeker-method-9 () none 9)
-    (widow-float-seeker-method-10 () none 10)
-    (widow-float-seeker-method-11 () none 11)
-    (widow-float-seeker-method-12 () none 12)
+    (widow-float-seeker-method-9 (_type_ float float float float float) none 9)
+    (widow-float-seeker-method-10 (_type_ (pointer float)) none 10)
+    (widow-float-seeker-method-11 (_type_ float) none 11)
+    (widow-float-seeker-method-12 (_type_ float) none 12)
     )
   )
-|#
 
-#|
 (deftype widow-rand-vector (structure)
   ((min-time int32          :offset-assert 0)
    (max-time int32          :offset-assert 4)
@@ -45882,13 +45855,11 @@
   :size-assert         #x30
   :flag-assert         #xb00000030
   (:methods
-    (widow-rand-vector-method-9 () none 9)
-    (widow-rand-vector-method-10 () none 10)
+    (init (_type_ int int float float) none 9)
+    (widow-rand-vector-method-10 (_type_) none 10)
     )
   )
-|#
 
-#|
 (deftype widow-oscillator (structure)
   ((target  vector :inline :offset-assert 0)
    (value   vector :inline :offset-assert 16)
@@ -45901,13 +45872,11 @@
   :size-assert         #x3c
   :flag-assert         #xb0000003c
   (:methods
-    (widow-oscillator-method-9 () none 9)
-    (widow-oscillator-method-10 () none 10)
+    (widow-oscillator-method-9 (_type_ vector float float float) none 9)
+    (widow-oscillator-method-10 (_type_ vector) none 10)
     )
   )
-|#
 
-#|
 (deftype widow-shot (guard-shot)
   ()
   :method-count-assert 40
@@ -45916,136 +45885,130 @@
   (:methods
     )
   )
-|#
 
-#|
 (deftype widow (process-drawable)
-  ((bomb                         UNKNOWN            8       :offset-assert 196)
-   (next-launch                  int32                      :offset-assert 260)
-   (launch-dest                  vector             :inline :offset-assert 268)
-   (next-jumper                  int32                      :offset-assert 284)
-   (ammos                        UNKNOWN            2       :offset-assert 292)
-   (ammo-timers                  UNKNOWN            2       :offset-assert 308)
-   (bomb-hits                    int32                      :offset-assert 324)
-   (circle-center                vector             :inline :offset-assert 332)
-   (theta                        cam-float-seeker   :inline :offset-assert 348)
-   (traj                         trajectory         :inline :offset-assert 380)
-   (osc                          widow-oscillator   :inline :offset-assert 428)
-   (noise-osc                    widow-oscillator   :inline :offset-assert 492)
-   (rand-vec                     widow-rand-vector  :inline :offset-assert 556)
-   (attack-from-high-deg         basic                      :offset-assert 604)
-   (which-gun                    int32                      :offset-assert 608)
-   (which-pod                    int32                      :offset-assert 612)
-   (left-cover-angle             widow-float-seeker :inline :offset-assert 616)
-   (right-cover-angle            widow-float-seeker :inline :offset-assert 644)
-   (left-cover-jm                basic                      :offset-assert 672)
-   (right-cover-jm               basic                      :offset-assert 676)
-   (drill-speed                  cam-float-seeker   :inline :offset-assert 680)
-   (drill-angle                  float                      :offset-assert 704)
-   (left-drill-jm                basic                      :offset-assert 708)
-   (right-drill-jm               basic                      :offset-assert 712)
-   (flying                       basic                      :offset-assert 716)
-   (previous-anim                int32                      :offset-assert 720)
-   (launched-a-bomb              basic                      :offset-assert 724)
-   (old-bomb-hits                int32                      :offset-assert 728)
-   (catwalk                      UNKNOWN            8       :offset-assert 732)
-   (heart                        uint64                     :offset-assert 796)
-   (pod                          uint64                     :offset-assert 804)
-   (baron                        uint32                     :offset-assert 812)
-   (drill-spark-part             basic                      :offset-assert 816)
-   (drill-spark-part-alt         basic                      :offset-assert 820)
-   (extract-stone-time           time-frame                     :offset-assert 828)
-   (extract-stone-part           basic                      :offset-assert 836)
-   (insert-stone-time            time-frame                     :offset-assert 844)
-   (insert-stone-part            basic                      :offset-assert 852)
-   (land-part                    basic                      :offset-assert 856)
-   (green-charge-part            basic                      :offset-assert 860)
-   (green-fire-part              basic                      :offset-assert 864)
-   (lightning                    UNKNOWN            5       :offset-assert 868)
-   (stop-catwalk-sound           basic                      :offset-assert 888)
-   (catwalk-sound                uint32                     :offset-assert 892)
-   (drill-sound                  uint32                     :offset-assert 896)
-   (drill-sound-playing          basic                      :offset-assert 900)
-   (drill-sweeten-sound          uint32                     :offset-assert 904)
-   (drill-sweeten-sound-playing  basic                      :offset-assert 908)
-   (movie-handle                 uint64                     :offset-assert 916)
-   (tilt                         cam-float-seeker   :inline :offset-assert 924)
-   (targetted-catwalk            int32                      :offset-assert 948)
-   (hover-sound                  uint32                     :offset-assert 952)
-   (hover-sound-playing          basic                      :offset-assert 956)
-   (shake-sound                  uint32                     :offset-assert 960)
-   (shake-sound-playing          basic                      :offset-assert 964)
-   (hud                          uint64                     :offset-assert 972)
-   (last-want-stone-talker       int8                       :offset-assert 980)
-   (last-general-flying-talker   int8                       :offset-assert 981)
-   (last-launch-droids-talker    int8                       :offset-assert 982)
-   (last-launch-bombs-talker     int8                       :offset-assert 983)
-   (last-shoot-gun-talker        int8                       :offset-assert 984)
-   (last-stone-charge-up-talker  int8                       :offset-assert 985)
-   (last-after-stone-shot-talker int8                       :offset-assert 986)
-   (last-leave-perch-talker      int8                       :offset-assert 987)
-   (last-damaged-talker          int8                       :offset-assert 988)
-   (kicked-bombs                 int8                       :offset-assert 989)
-   (launch-stages-completed      int8                       :offset-assert 990)
-   (current-shoot-stage          int16                      :offset-assert 992)
-   (last-gun-hit-stage           int16                      :offset-assert 994)
-   (gun-hits                     int16                      :offset-assert 996)
-   (last-attack-id               uint32                     :offset-assert 1000)
+  ((bomb                         handle             8       :offset-assert 200)
+   (next-launch                  int32                      :offset-assert 264)
+   (launch-dest                  vector             :inline :offset-assert 272)
+   (next-jumper                  int32                      :offset-assert 288)
+   (ammos                        handle             2       :offset-assert 296)
+   (ammo-timers                  time-frame         2       :offset-assert 312)
+   (bomb-hits                    int32                      :offset-assert 328)
+   (circle-center                vector             :inline :offset-assert 336)
+   (theta                        cam-float-seeker   :inline :offset-assert 352)
+   (traj                         trajectory         :inline :offset-assert 384)
+   (osc                          widow-oscillator   :inline :offset-assert 432)
+   (noise-osc                    widow-oscillator   :inline :offset-assert 496)
+   (rand-vec                     widow-rand-vector  :inline :offset-assert 560)
+   (attack-from-high-deg         symbol                     :offset-assert 608)
+   (which-gun                    int32                      :offset-assert 612)
+   (which-pod                    int32                      :offset-assert 616)
+   (left-cover-angle             widow-float-seeker :inline :offset 620)
+   (right-cover-angle            widow-float-seeker :inline :offset 648)
+   (left-cover-jm                joint-mod                  :offset-assert 676)
+   (right-cover-jm               joint-mod                  :offset-assert 680)
+   (drill-speed                  cam-float-seeker   :inline :offset-assert 684)
+   (drill-angle                  float                      :offset-assert 708)
+   (left-drill-jm                joint-mod                  :offset-assert 712)
+   (right-drill-jm               joint-mod                  :offset-assert 716)
+   (flying                       symbol                     :offset-assert 720)
+   (previous-anim                int32                      :offset-assert 724)
+   (launched-a-bomb              symbol                     :offset-assert 728)
+   (old-bomb-hits                int32                      :offset-assert 732)
+   (catwalk                      handle  8                  :offset-assert 736)
+   (heart                        handle                     :offset-assert 800)
+   (pod                          handle                     :offset-assert 808)
+   (baron                        (pointer manipy)           :offset-assert 816)
+   (drill-spark-part             sparticle-launch-control   :offset-assert 820)
+   (drill-spark-part-alt         sparticle-launch-control   :offset-assert 824)
+   (extract-stone-time           time-frame                 :offset-assert 832)
+   (extract-stone-part           sparticle-launch-control   :offset-assert 840)
+   (insert-stone-time            time-frame                 :offset-assert 848)
+   (insert-stone-part            sparticle-launch-control   :offset-assert 856)
+   (land-part                    sparticle-launch-control   :offset-assert 860)
+   (green-charge-part            sparticle-launch-control   :offset-assert 864)
+   (green-fire-part              sparticle-launch-control   :offset-assert 868)
+   (lightning                    lightning-control  5       :offset-assert 872)
+   (stop-catwalk-sound           symbol                     :offset-assert 892)
+   (catwalk-sound                uint32                     :offset-assert 896)
+   (drill-sound                  uint32                     :offset-assert 900)
+   (drill-sound-playing          symbol                     :offset-assert 904)
+   (drill-sweeten-sound          uint32                     :offset-assert 908)
+   (drill-sweeten-sound-playing  symbol                     :offset-assert 912)
+   (movie-handle                 handle                     :offset-assert 920)
+   (tilt                         cam-float-seeker   :inline :offset-assert 928)
+   (targetted-catwalk            int32                      :offset-assert 952)
+   (hover-sound                  uint32                     :offset-assert 956)
+   (hover-sound-playing          symbol                     :offset-assert 960)
+   (shake-sound                  uint32                     :offset-assert 964)
+   (shake-sound-playing          symbol                     :offset-assert 968)
+   (hud                          handle                     :offset-assert 976)
+   (last-want-stone-talker       int8                       :offset-assert 984)
+   (last-general-flying-talker   int8                       :offset-assert 985)
+   (last-launch-droids-talker    int8                       :offset-assert 986)
+   (last-launch-bombs-talker     int8                       :offset-assert 987)
+   (last-shoot-gun-talker        int8                       :offset-assert 988)
+   (last-stone-charge-up-talker  int8                       :offset-assert 989)
+   (last-after-stone-shot-talker int8                       :offset-assert 990)
+   (last-leave-perch-talker      int8                       :offset-assert 991)
+   (last-damaged-talker          int8                       :offset-assert 992)
+   (kicked-bombs                 int8                       :offset-assert 993)
+   (launch-stages-completed      int8                       :offset-assert 994)
+   (current-shoot-stage          int16                      :offset-assert 996)
+   (last-gun-hit-stage           int16                      :offset-assert 998)
+   (gun-hits                     int16                      :offset-assert 1000)
+   (last-attack-id               uint32                     :offset-assert 1004)
    )
   :method-count-assert 47
   :size-assert         #x3f0
   :flag-assert         #x2f037003f0
   (:methods
-    (widow-method-20 () none 20)
-    (widow-method-21 () none 21)
-    (widow-method-22 () none 22)
-    (widow-method-23 () none 23)
-    (widow-method-24 () none 24)
-    (widow-method-25 () none 25)
-    (widow-method-26 () none 26)
-    (widow-method-27 () none 27)
-    (widow-method-28 () none 28)
-    (widow-method-29 () none 29)
-    (widow-method-30 () none 30)
-    (widow-method-31 () none 31)
-    (widow-method-32 () none 32)
-    (widow-method-33 () none 33)
-    (widow-method-34 () none 34)
-    (widow-method-35 () none 35)
-    (widow-method-36 () none 36)
-    (widow-method-37 () none 37)
-    (widow-method-38 () none 38)
-    (widow-method-39 () none 39)
-    (widow-method-40 () none 40)
-    (widow-method-41 () none 41)
-    (widow-method-42 () none 42)
-    (widow-method-43 () none 43)
-    (widow-method-44 () none 44)
-    (widow-method-45 () none 45)
-    (widow-method-46 () none 46)
+    (beaten () _type_ :state 20)
+    (kaboom () _type_ :state 21)
+    (hover-low-stage-3 () _type_ :state 22)
+    (hover-shooting-stage-3 () _type_ :state 23)
+    (hover-launch-bombs-stage-3 () _type_ :state 24)
+    (hover-big-blast-stage-3 () _type_ :state 25)
+    (hover-rise-stage-3 () _type_ :state 26)
+    (hover-jump-down-stage-3 () _type_ :state 27)
+    (big-reaction-stage-2 () _type_ :state 28)
+    (watch-bombs-stage-2 () _type_ :state 29)
+    (launch-bombs-stage-2 () _type_ :state 30)
+    (back-to-perch-stage-2 () _type_ :state 31)
+    (hover-low-stage-2 () _type_ :state 32)
+    (hover-shooting-stage-2 () _type_ :state 33)
+    (hover-rise-stage-2 () _type_ :state 34)
+    (hover-seek-under-stage-2 () _type_ :state 35)
+    (hover-jump-down-stage-2 () _type_ :state 36)
+    (launch-droids-stage-2 () _type_ :state 37)
+    (big-reaction-stage-1 () _type_ :state 38)
+    (watch-bombs-stage-1 () _type_ :state 39)
+    (launch-bombs-stage-1 () _type_ :state 40)
+    (watch-droids-stage-1 () _type_ :state 41)
+    (launch-droids-stage-1 () _type_ :state 42)
+    (hidden () _type_ :state 43)
+    (widow-method-44 (_type_ vector vector) symbol 44)
+    (widow-method-45 (_type_ vector vector vector) none 45)
+    (widow-method-46 (_type_ vector int) none 46)
     )
   )
-|#
 
-#|
 (deftype baron-pod (process-drawable)
-  ((red-tip-change-time time-frame  :offset-assert 196)
-   (alt-red-tip-on      basic   :offset-assert 204)
-   (blink-time          time-frame  :offset-assert 212)
-   (blink-mask          int32   :offset-assert 220)
-   (has-stone           basic   :offset-assert 224)
+  ((red-tip-change-time time-frame  :offset-assert 200)
+   (alt-red-tip-on      symbol      :offset-assert 208)
+   (blink-time          time-frame  :offset-assert 216)
+   (blink-mask          int32       :offset-assert 224)
+   (has-stone           symbol      :offset-assert 228)
    )
   :method-count-assert 22
   :size-assert         #xe8
   :flag-assert         #x16007000e8
   (:methods
     (idle () _type_ :state 20)
-    (baron-pod-method-21 () none 21)
+    (baron-pod-method-21 (_type_ symbol) none 21)
     )
   )
-|#
 
-#|
 (deftype tomb-boss-bridge (process-drawable)
   ()
   :method-count-assert 21
@@ -46055,27 +46018,26 @@
     (idle () _type_ :state 20)
     )
   )
-|#
 
-;; (define-extern baron-pod-init-by-other function)
-;; (define-extern widow-want-stone-talker function)
-;; (define-extern widow-general-flying-talker function)
-;; (define-extern widow-launch-droids-talker function)
-;; (define-extern widow-launch-bombs-talker function)
-;; (define-extern widow-shoot-gun-talker function)
-;; (define-extern widow-stone-charge-up-talker function)
-;; (define-extern widow-after-stone-shot-talker function)
-;; (define-extern widow-leave-perch-talker function)
-;; (define-extern widow-damaged-talker function)
-;; (define-extern widow-handler function)
+(define-extern baron-pod-init-by-other (function vector none :behavior baron-pod))
+(define-extern widow-want-stone-talker (function int :behavior widow))
+(define-extern widow-general-flying-talker (function int :behavior widow))
+(define-extern widow-launch-droids-talker (function int :behavior widow))
+(define-extern widow-launch-bombs-talker (function int :behavior widow))
+(define-extern widow-shoot-gun-talker (function int :behavior widow))
+(define-extern widow-stone-charge-up-talker (function int :behavior widow))
+(define-extern widow-after-stone-shot-talker (function int :behavior widow))
+(define-extern widow-leave-perch-talker (function int :behavior widow))
+(define-extern widow-damaged-talker (function int :behavior widow))
+(define-extern widow-handler (function process int symbol event-message-block object :behavior widow))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; widow-extras                   ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype tomb-boss-catwalk (process-drawable)
-  ((which-look int32  :offset-assert 196)
+  ((root-override collide-shape-moving :offset 128 :score 1)
+   (which-look int32  :offset-assert 200)
    )
   :method-count-assert 23
   :size-assert         #xcc
@@ -46083,12 +46045,10 @@
   (:methods
     (shatter () _type_ :state 20)
     (idle () _type_ :state 21)
-    (tomb-boss-catwalk-method-22 () none 22)
+    (tomb-boss-catwalk-method-22 (_type_ vector int) none 22)
     )
   )
-|#
 
-#|
 (deftype tomb-boss-catwalk-main (tomb-boss-catwalk)
   ()
   :method-count-assert 23
@@ -46097,27 +46057,25 @@
   (:methods
     )
   )
-|#
 
-#|
 (deftype widow-bomb (process-focusable)
-  ((traj                  trajectory     :inline :offset-assert 204)
-   (explode-part          basic                  :offset-assert 244)
-   (trail-part            basic                  :offset-assert 248)
-   (warning-glow-part     basic                  :offset-assert 252)
-   (warning-spark-part    basic                  :offset-assert 256)
-   (impact                impact-control :inline :offset-assert 268)
-   (which-trajectory      int32                  :offset-assert 348)
-   (next-countdown-tick   uint64                 :offset-assert 356)
-   (skid-part             basic                  :offset-assert 364)
-   (x-rotate              float                  :offset-assert 368)
-   (y-rotate              float                  :offset-assert 372)
-   (spin-jm               basic                  :offset-assert 376)
-   (firework-sound-played basic                  :offset-assert 380)
-   (steam-sound           uint32                 :offset-assert 384)
-   (launch                vector         :inline :offset-assert 396)
-   (launch-pos            vector         :inline :offset-assert 412)
-   (fizzle-timer          uint64                 :offset-assert 428)
+  ((traj                  trajectory       :inline :offset-assert 208)
+   (explode-part          sparticle-launch-control :offset-assert 248)
+   (trail-part            sparticle-launch-control :offset-assert 252)
+   (warning-glow-part     sparticle-launch-control :offset-assert 256)
+   (warning-spark-part    sparticle-launch-control :offset-assert 260)
+   (impact                impact-control   :inline :offset-assert 272)
+   (which-trajectory      int32                    :offset-assert 352)
+   (next-countdown-tick   time-frame               :offset-assert 360)
+   (skid-part             sparticle-launch-control :offset-assert 368)
+   (x-rotate              float                    :offset-assert 372)
+   (y-rotate              float                    :offset-assert 376)
+   (spin-jm               joint-mod                :offset-assert 380)
+   (firework-sound-played symbol                   :offset-assert 384)
+   (steam-sound           uint32                   :offset-assert 388)
+   (launch                vector           :inline :offset-assert 400)
+   (launch-pos            vector           :inline :offset-assert 416)
+   (fizzle-timer          time-frame               :offset-assert 432)
    )
   :method-count-assert 35
   :size-assert         #x1b8
@@ -46128,16 +46086,15 @@
     (explode () _type_ :state 29)
     (smoke () _type_ :state 30)
     (idle () _type_ :state 31)
-    (widow-bomb-method-32 () none 32)
-    (widow-bomb-method-33 () none 33)
-    (widow-bomb-method-34 () none 34)
+    (widow-bomb-method-32 (_type_) none 32)
+    (widow-bomb-method-33 (_type_) none 33)
+    (widow-bomb-method-34 (_type_) none 34)
     )
   )
-|#
 
-#|
 (deftype heart-mar (process-drawable)
-  ()
+  ((root-override collide-shape-moving :offset 128 :score 1)
+   )
   :method-count-assert 21
   :size-assert         #xc8
   :flag-assert         #x15005000c8
@@ -46145,13 +46102,12 @@
     (idle () _type_ :state 20)
     )
   )
-|#
 
-#|
 (deftype tomb-boss-pillar (process-drawable)
-  ((explode-part    basic   :offset-assert 196)
-   (segs-shot       int32   :offset-assert 200)
-   (last-pillar-hit uint64  :offset-assert 204)
+  ((root-override   collide-shape-moving     :offset 128 :score 1)
+   (explode-part    sparticle-launch-control :offset-assert 200)
+   (segs-shot       int32                    :offset-assert 204)
+   (last-pillar-hit time-frame               :offset-assert 208)
    )
   :method-count-assert 23
   :size-assert         #xd8
@@ -46162,11 +46118,10 @@
     (broken () _type_ :state 22)
     )
   )
-|#
 
-#|
 (deftype tomb-boss-firepot (process-drawable)
-  ()
+  ((root-override collide-shape-moving :offset 128 :score 1)
+   )
   :method-count-assert 23
   :size-assert         #xc8
   :flag-assert         #x17005000c8
@@ -46176,29 +46131,28 @@
     (broken () _type_ :state 22)
     )
   )
-|#
 
-;; (define-extern tomb-boss-catwalk-init-by-other function)
-;; (define-extern widow-bomb-handler function)
-;; (define-extern widow-bomb-back-handler function)
-;; (define-extern widow-bomb-reaction function)
-;; (define-extern widow-bomb-init-by-other function)
-;; (define-extern heart-mar-init-by-other function)
-;; (define-extern damage-pillar function)
-;; (define-extern tomb-boss-pillar-shrink-collision function)
-;; (define-extern tomb-boss-firepot-shrink-collision function)
+(define-extern tomb-boss-catwalk-init-by-other (function vector int none :behavior tomb-boss-catwalk))
+(define-extern widow-bomb-handler (function process int symbol event-message-block none :behavior widow-bomb))
+(define-extern widow-bomb-back-handler (function process int symbol event-message-block none :behavior widow-bomb))
+(define-extern widow-bomb-reaction (function control-info collide-query vector vector collide-status :behavior widow))
+(define-extern widow-bomb-init-by-other (function vector vector float float vector none :behavior widow-bomb))
+(define-extern heart-mar-init-by-other (function vector none :behavior heart-mar))
+(define-extern damage-pillar (function none :behavior tomb-boss-pillar))
+(define-extern tomb-boss-pillar-shrink-collision (function none :behavior tomb-boss-pillar))
+(define-extern tomb-boss-firepot-shrink-collision (function none :behavior tomb-boss-firepot))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; widow-more-extras              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype tomb-boss-debris (process-drawable)
-  ((y-velocity  float              :offset-assert 196)
-   (floor       float              :offset-assert 200)
-   (sound-floor float              :offset-assert 204)
-   (rot         quaternion :inline :offset-assert 220)
-   (look        int32              :offset-assert 236)
+  ((root-override collide-shape-moving :offset 128 :score 1)
+   (y-velocity    float              :offset-assert 200)
+   (floor         float              :offset-assert 204)
+   (sound-floor   float              :offset-assert 208)
+   (rot           quaternion :inline :offset-assert 224)
+   (look          int32              :offset-assert 240)
    )
   :method-count-assert 22
   :size-assert         #xf4
@@ -46208,11 +46162,9 @@
     (idle () _type_ :state 21)
     )
   )
-|#
 
-#|
 (deftype cave-in-master (process-drawable)
-  ((prev-points UNKNOWN 100 :offset-assert 196)
+  ((prev-points int32 100 :offset-assert 200)
    )
   :method-count-assert 22
   :size-assert         #x258
@@ -46222,33 +46174,32 @@
     (wait () _type_ :state 21)
     )
   )
-|#
 
-;; (define-extern tomb-boss-debris-init-by-other function)
-;; (define-extern cavein-get-random-point function)
+(define-extern tomb-boss-debris-init-by-other (function vector int none :behavior tomb-boss-debris))
+(define-extern cavein-get-random-point (function vector vector :behavior cave-in-master))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; widow                          ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern widow-common function)
-;; (define-extern widow-calc-position function)
-;; (define-extern widow-calc-target-position function)
-;; (define-extern widow-calc-root-from-osc function)
-;; (define-extern widow-next-pod function)
-;; (define-extern widow-pod-position function)
-;; (define-extern spydroid-setup function)
-;; (define-extern widow-bomb-setup function)
-;; (define-extern spydroid-launch function)
-;; (define-extern widow-bomb-launch function)
-;; (define-extern widow-give-ammo function)
-;; (define-extern widow-bomb-slots-full function)
-;; (define-extern widow-debug function)
-;; (define-extern widow-cleanup-launch-anim function)
-;; (define-extern widow-last-bomb-anim function)
-;; (define-extern widow-flying-anim function)
-;; (define-extern widow-kaboom-check function)
-;; (define-extern hover-seek-under-stage-3 state)
+(define-extern widow-common (function none :behavior widow))
+(define-extern widow-calc-position (function vector float float float vector :behavior widow))
+(define-extern widow-calc-target-position (function vector vector :behavior widow))
+(define-extern widow-calc-root-from-osc (function float quaternion :behavior widow))
+(define-extern widow-next-pod (function none :behavior widow))
+(define-extern widow-pod-position (function vector symbol float none :behavior widow))
+(define-extern spydroid-setup (function none :behavior widow))
+(define-extern widow-bomb-setup (function none :behavior widow))
+(define-extern spydroid-launch (function int :behavior widow))
+(define-extern widow-bomb-launch (function symbol symbol symbol int :behavior widow))
+(define-extern widow-give-ammo (function none :behavior widow))
+(define-extern widow-bomb-slots-full (function int :behavior widow))
+(define-extern widow-debug (function none :behavior widow))
+(define-extern widow-cleanup-launch-anim (function symbol none :behavior widow))
+(define-extern widow-last-bomb-anim (function none :behavior widow))
+(define-extern widow-flying-anim (function none :behavior widow))
+(define-extern widow-kaboom-check (function symbol none :behavior widow))
+(define-extern hover-seek-under-stage-3 (state widow))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; widow2                         ;;
@@ -49770,53 +49721,48 @@
 ;; transport                      ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype vehicle-turret (process-focusable)
-  ((turret-jm basic                  :offset-assert 200)
-   (turret    turret-control :inline :offset-assert 204)
-   (target    uint64                 :offset-assert 284)
+  ((turret-jm joint-mod              :offset-assert 204)
+   (turret    turret-control :inline :offset-assert 208)
+   (target    handle                 :offset-assert 288)
    )
   :method-count-assert 31
   :size-assert         #x128
   :flag-assert         #x1f00b00128
   (:methods
     (idle () _type_ :state 27)
-    (vehicle-turret-method-28 () none 28)
-    (vehicle-turret-method-29 () none 29)
-    (vehicle-turret-method-30 () none 30)
+    (vehicle-turret-method-28 (_type_) none 28)
+    (vehicle-turret-method-29 (_type_) none 29)
+    (vehicle-turret-method-30 (_type_) none 30)
     )
   )
-|#
 
-#|
 (deftype transport-params (structure)
   ((spawn-pos vector     :inline :offset-assert 0)
    (quat      quaternion :inline :offset-assert 16)
-   (nav-mesh  basic              :offset-assert 32)
+   (nav-mesh  nav-mesh           :offset-assert 32)
    (max-guard uint32             :offset-assert 36)
    (max-time  float              :offset-assert 40)
-   (turret?   basic              :offset-assert 44)
-   (speeches? basic              :offset-assert 48)
+   (turret?   symbol             :offset-assert 44)
+   (speeches? symbol             :offset-assert 48)
    )
   :method-count-assert 9
   :size-assert         #x34
   :flag-assert         #x900000034
   )
-|#
 
-#|
 (deftype transport (process-focusable)
-  ((y-dest                float   :offset-assert 200)
-   (last-guard-spawn-time time-frame  :offset-assert 204)
-   (nav-mesh              basic   :offset-assert 212)
-   (spawn-side            uint32  :offset-assert 216)
-   (spawn?                basic   :offset-assert 220)
-   (leave-time            time-frame  :offset-assert 228)
-   (max-guard             uint32  :offset-assert 236)
-   (count-guard           uint32  :offset-assert 240)
-   (max-time              float   :offset-assert 244)
-   (ambient-sound-id      uint32  :offset-assert 248)
-   (turret                uint64  :offset-assert 252)
+  ((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)
+   (ambient-sound-id      uint32  :offset-assert 252)
+   (turret                handle  :offset-assert 256)
    )
   :method-count-assert 36
   :size-assert         #x108
@@ -49826,20 +49772,19 @@
     (idle () _type_ :state 28)
     (leave () _type_ :state 29)
     (die-fast () _type_ :state 30)
-    (transport-method-31 () none 31)
-    (transport-method-32 () none 32)
-    (transport-method-33 () none 33)
-    (transport-method-34 () none 34)
-    (transport-method-35 () none 35)
+    (transport-method-31 (_type_) none 31)
+    (transport-method-32 (_type_) none 32)
+    (transport-method-33 (_type_) none 33)
+    (transport-method-34 (_type_ process) none 34)
+    (transport-method-35 (_type_) none 35)
     )
   )
-|#
 
-;; (define-extern *transport-turret-state-info* object)
-;; (define-extern vehicle-turret-init-by-other function)
-;; (define-extern *transport-turret-control-info* object)
-;; (define-extern transport-event-handler function)
-;; (define-extern transport-init-by-other function)
+(define-extern *transport-turret-state-info* traffic-guard-type-settings)
+(define-extern vehicle-turret-init-by-other (function turret-control-info none :behavior vehicle-turret))
+(define-extern *transport-turret-control-info* turret-control-info)
+(define-extern transport-event-handler (function process int symbol event-message-block object :behavior transport))
+(define-extern transport-init-by-other (function transport-params none :behavior transport))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; race-h                         ;;
@@ -51668,33 +51613,32 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (deftype kid (bot)
-  ((travel-anim-interp  float   :offset-assert 992)
-   (arrest-attempt-time time-frame  :offset-assert 1000)
-   (arrestor-handle     uint64  :offset-assert 1008)
+  ((travel-anim-interp  float      :offset-assert 992)
+   (arrest-attempt-time time-frame :offset-assert 1000)
+   (arrestor-handle     handle     :offset-assert 1008)
    )
   :method-count-assert 235
   :size-assert         #x3f8
   :flag-assert         #xeb038003f8
   (:methods
-    (kid-method-225 () none 225)
-    (kid-method-226 () none 226)
-    (kid-method-227 () none 227)
-    (kid-method-228 () none 228)
-    (kid-method-229 () none 229)
-    (kid-method-230 () none 230)
-    (kid-method-231 () none 231)
-    (kid-method-232 () none 232)
-    (kid-method-233 () none 233)
-    (kid-method-234 () none 234)
+    (traveling () _type_ :state 225)
+    (traveling-blocked () _type_ :state 226)
+    (waiting-with-kor () _type_ :state 227)
+    (waiting-idle () _type_ :state 228)
+    (waiting-turn () _type_ :state 229)
+    (scared-idle () _type_ :state 230)
+    (arrested () _type_ :state 231)
+    (kid-method-232 (_type_) none 232)
+    (kid-method-233 (_type_) none 233)
+    (kid-method-234 (_type_) none 234)
     )
   )
 
-#|
 (deftype kidt-wait-spot (ai-task)
-  ((check-done   basic     :offset-assert 32)
-   (which-spot   int8      :offset-assert 36)
-   (num-spots    uint8     :offset-assert 37)
-   (spot-indexes UNKNOWN 6 :offset-assert 38)
+  ((check-done   (function kidt-wait-spot kid symbol) :offset 32)
+   (which-spot   int8      :offset 36)
+   (num-spots    uint8     :offset 37)
+   (spot-indexes uint8 6   :offset 38)
    )
   :method-count-assert 12
   :size-assert         #x30
@@ -51702,43 +51646,38 @@
   (:methods
     )
   )
-|#
-
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; kor-h                          ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype kor (bot)
-  ((travel-anim-interp  float   :offset-assert 988)
-   (arrest-attempt-time time-frame  :offset-assert 996)
-   (arrestor-handle     uint64  :offset-assert 1004)
+  ((travel-anim-interp  float      :offset-assert 992)
+   (arrest-attempt-time time-frame :offset-assert 1000)
+   (arrestor-handle     handle     :offset-assert 1008)
    )
   :method-count-assert 235
   :size-assert         #x3f8
   :flag-assert         #xeb038003f8
   (:methods
-    (kor-method-225 () none 225)
-    (kor-method-226 () none 226)
-    (kor-method-227 () none 227)
-    (kor-method-228 () none 228)
-    (kor-method-229 () none 229)
-    (kor-method-230 () none 230)
-    (kor-method-231 () none 231)
-    (kor-method-232 () none 232)
-    (kor-method-233 () none 233)
-    (kor-method-234 () none 234)
+    (traveling () _type_ :state 225)
+    (traveling-blocked () _type_ :state 226)
+    (waiting-with-kid () _type_ :state 227)
+    (waiting-idle () _type_ :state 228)
+    (waiting-turn () _type_ :state 229)
+    (scared-idle () _type_ :state 230)
+    (arrested () _type_ :state 231)
+    (kor-method-232 (_type_) none 232)
+    (kor-method-233 (_type_) none 233)
+    (kor-method-234 (_type_) none 234)
     )
   )
-|#
 
-#|
 (deftype kort-wait-spot (ai-task)
-  ((check-done   basic     :offset-assert 32)
-   (which-spot   int8      :offset-assert 36)
-   (num-spots    uint8     :offset-assert 37)
-   (spot-indexes UNKNOWN 6 :offset-assert 38)
+  ((check-done   (function kort-wait-spot kor symbol) :offset 32)
+   (which-spot   int8      :offset 36)
+   (num-spots    uint8     :offset 37)
+   (spot-indexes uint8 6   :offset 38)
    )
   :method-count-assert 12
   :size-assert         #x30
@@ -51746,41 +51685,35 @@
   (:methods
     )
   )
-|#
-
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; hal3-course                    ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype hal3-course (bot-course)
-  ((transport uint64  :offset-assert 48)
+  ((transport handle  :offset-assert 48)
    )
   :method-count-assert 9
   :size-assert         #x38
   :flag-assert         #x900000038
   ;; field default-check-too-far uses ~A with a signed load
   )
-|#
 
-#|
 (deftype hal-help-kid (hal)
-  ((nav-mesh   basic                :offset-assert 1020)
-   (alley-bbox bounding-box :inline :offset-assert 1036)
-   (suppress   UNKNOWN      2       :offset-assert 1068)
+  ((nav-mesh   nav-mesh             :offset-assert 1024)
+   (alley-bbox bounding-box :inline :offset-assert 1040)
+   (suppress   traffic-suppression-params 2 :inline :offset-assert 1072)
    )
   :method-count-assert 229
   :size-assert         #x490
   :flag-assert         #xe504100490
   (:methods
-    (hal-help-kid-method-227 () none 227)
-    (hal-help-kid-method-228 () none 228)
+    (hal-help-kid-method-227 (_type_) none 227)
+    (hal-help-kid-method-228 (_type_ vector) none 228)
     )
   )
-|#
 
-;; (define-extern *hal3-course* hal3-course)
+(define-extern *hal3-course* hal3-course)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; kid-task                       ;;
@@ -51791,7 +51724,7 @@
 ;; kid                            ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *kid-nav-enemy-info* nav-enemy-info)
+(define-extern *kid-nav-enemy-info* nav-enemy-info)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; kid-states                     ;;
@@ -51807,7 +51740,6 @@
 ;; kor                            ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype kor-anim-info (structure)
   ((anim-index int32  :offset-assert 0)
    )
@@ -51815,9 +51747,8 @@
   :size-assert         #x4
   :flag-assert         #x900000004
   )
-|#
 
-;; (define-extern *kor-nav-enemy-info* nav-enemy-info)
+(define-extern *kor-nav-enemy-info* nav-enemy-info)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; kor-states                     ;;
@@ -51828,15 +51759,15 @@
 ;; kid3-course                    ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern kid-update-during-battle function)
-;; (define-extern *kid3-course* bot-course)
+(define-extern kid-update-during-battle (function kid none))
+(define-extern *kid3-course* bot-course)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; kor3-course                    ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern kor-update-during-battle function)
-;; (define-extern *kor3-course* bot-course)
+(define-extern kor-update-during-battle (function kor none))
+(define-extern *kor3-course* bot-course)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; ruins-ocean                    ;;
diff --git a/decompiler/config/jak2/anonymous_function_types.jsonc b/decompiler/config/jak2/anonymous_function_types.jsonc
index e1e16df405..7c6eeb542c 100644
--- a/decompiler/config/jak2/anonymous_function_types.jsonc
+++ b/decompiler/config/jak2/anonymous_function_types.jsonc
@@ -858,5 +858,64 @@
     [16, "(function none)"],
     [17, "(function process-drawable vector cspace object)"],
     [18, "(function object)"]
+  ],
+  "mantis": [
+    [8, "(function mantis vector float float vector vector)"],
+    [15, "(function mantis collide-shape-moving vector symbol)"]
+  ],
+  "mammoth": [[11, "(function vector vector vector vector vector)"]],
+  "atoll-obs": [[0, "(function symbol :behavior task-manager)"]],
+  "spydroid": [[18, "(function (pointer process) :behavior spydroid)"]],
+  "kid3-course": [
+    [0, "(function kid none)"],
+    [1, "(function symbol)"],
+    [2, "(function kid none)"],
+    [3, "(function object kid symbol)"],
+    [4, "(function kid none)"],
+    [5, "(function kid none)"],
+    [6, "(function object kid symbol)"],
+    [7, "(function kid none)"],
+    [8, "(function kid none)"],
+    [9, "(function object kid symbol)"],
+    [10, "(function kid none)"],
+    [11, "(function object kid symbol)"],
+    [12, "(function kid none)"],
+    [13, "(function object kid symbol)"]
+  ],
+  "kor3-course": [
+    [0, "(function kor none)"],
+    [1, "(function symbol)"],
+    [2, "(function kor none)"],
+    [3, "(function object kor symbol)"],
+    [4, "(function kor none)"],
+    [5, "(function kor none)"],
+    [6, "(function object kor symbol)"],
+    [7, "(function kor none)"],
+    [8, "(function kor none)"],
+    [9, "(function object kor symbol)"],
+    [10, "(function kor none)"],
+    [11, "(function object kor symbol)"],
+    [12, "(function kor none)"],
+    [13, "(function object kor symbol)"]
+  ],
+  "hal3-course": [
+    [0, "(function hal-help-kid none)"],
+    [1, "(function object hal-help-kid symbol)"],
+    [2, "(function hal-help-kid none)"],
+    [3, "(function object hal-help-kid symbol)"],
+    [4, "(function hal-help-kid none)"],
+    [5, "(function object hal-help-kid symbol)"],
+    [6, "(function hal-help-kid none)"],
+    [7, "(function hal-help-kid none)"],
+    [8, "(function hal-help-kid symbol)"],
+    [9, "(function hal-help-kid object)"],
+    [10, "(function hal-help-kid none)"],
+    [11, "(function object hal-help-kid symbol)"],
+    [12, "(function hal-help-kid none)"],
+    [13, "(function object hal-help-kid symbol)"],
+    [14, "(function hal-help-kid none)"],
+    [15, "(function object hal-help-kid symbol)"],
+    [16, "(function hal-help-kid none)"],
+    [17, "(function object hal-help-kid symbol)"]
   ]
 }
diff --git a/decompiler/config/jak2/hacks.jsonc b/decompiler/config/jak2/hacks.jsonc
index c081b9fd1f..a6a7c6352a 100644
--- a/decompiler/config/jak2/hacks.jsonc
+++ b/decompiler/config/jak2/hacks.jsonc
@@ -36,7 +36,6 @@
   "asm_functions_by_name": [
     // checking boxed type is different now - these make the cfg stuff sad
     "name=",
-    "(method 77 spyder)",
     "(method 77 flamer)",
     "(method 77 grenadier)",
     // until loop without nop:
@@ -517,7 +516,14 @@
     ],
     "(anon-function 2 ruins-obs)": [7, 28, 37, 50, 51, 61, 62, 71],
     "(anon-function 62 sig0-course)": [0, 1, 5, 6],
-    "(method 67 collide-shape-moving)": [0, 1, 2, 3, 11, 12, 13]
+    "(method 67 collide-shape-moving)": [0, 1, 2, 3, 11, 12, 13],
+    "(anon-function 12 juicer)": [29, 30],
+    "(anon-function 0 atoll-obs)": [11, 19, 20],
+    "(method 74 spydroid)": [12], // stack spill delay slot
+    "(anon-function 16 kid-states)": [4, 5],
+    "(anon-function 23 kid-states)": [4, 5],
+    "(anon-function 16 kor-states)": [4, 5],
+    "(anon-function 23 kor-states)": [4, 5]
   },
 
   // 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 ece441fe79..14ec92ac53 100644
--- a/decompiler/config/jak2/inputs.jsonc
+++ b/decompiler/config/jak2/inputs.jsonc
@@ -61,7 +61,7 @@
     // "DGO/LJAKDAX.DGO",
     "DGO/FORDUMPC.DGO",
     // "DGO/LTRNTESS.DGO",
-    // "DGO/TBO.DGO",
+    "DGO/TBO.DGO",
     "DGO/THR.DGO",
     "DGO/PRI.DGO",
     "DGO/LKIDDOGE.DGO",
@@ -88,7 +88,7 @@
     "DGO/COA.DGO",
     // "DGO/LTESS.DGO",
     "DGO/CFA.DGO",
-    // "DGO/TOMBEXT.DGO",
+    "DGO/TOMBEXT.DGO",
     "DGO/LCGUARD.DGO",
     "DGO/TOE.DGO",
     // "DGO/PALBOSS.DGO",
@@ -149,7 +149,7 @@
     "DGO/CPO.DGO",
     "DGO/CAP.DGO",
     "DGO/CWI.DGO",
-    // "DGO/CTYKORA.DGO",
+    "DGO/CTYKORA.DGO",
     "DGO/RUI.DGO",
     "DGO/LSACK.DGO",
     // "DGO/CTYASHA.DGO",
@@ -197,6 +197,7 @@
     "CTA.DGO",
     "CTB.DGO",
     "CTC.DGO",
+    "CTYKORA.DGO",
     "CWI.DGO",
     "D3A.DGO",
     "D3B.DGO",
@@ -228,6 +229,8 @@
     "LWIDEC.DGO",
     "MTN.DGO",
     "MTX.DGO",
+    "NES.DGO",
+    "NEB.DGO",
     "ONINTENT.DGO",
     "ORACLE.DGO",
     "MTN.DGO",
@@ -239,11 +242,13 @@
     "SKA.DGO",
     "STA.DGO",
     "STR.DGO",
+    "TBO.DGO",
     "TOA.DGO",
     "TOB.DGO",
     "TOC.DGO",
     "TOD.DGO",
     "TOE.DGO",
+    "TOMBEXT.DGO",
     "VI1.DGO",
     "VIN.DGO"
   ]
diff --git a/decompiler/config/jak2/label_types.jsonc b/decompiler/config/jak2/label_types.jsonc
index 0847172dd2..3a13d4d352 100644
--- a/decompiler/config/jak2/label_types.jsonc
+++ b/decompiler/config/jak2/label_types.jsonc
@@ -1076,5 +1076,81 @@
     ["L1152", "uint64", true],
     ["L1153", "uint64", true],
     ["L1154", "uint64", true]
+  ],
+  "juicer": [
+    ["L275", "vector"],
+    ["L274", "vector"],
+    ["L276", "vector"]
+  ],
+  "spyder": [
+    ["L179", "vector"],
+    ["L180", "vector"],
+    ["L190", "(inline-array ik-setup)", 4],
+    ["L191", "(pointer int32)", 4],
+    ["L192", "(pointer uint64)", 3]
+  ],
+  "mammoth": [
+    ["L170", "(pointer uint32)", 4],
+    ["L169", "attack-info"],
+    ["L177", "(inline-array mammoth-ik-setup)", 4]
+  ],
+  "flying-spider": [
+    ["L125", "vector"],
+    ["L124", "vector"]
+  ],
+  "nest-obs": [
+    ["L52", "uint64", true],
+    ["L53", "uint64", true]
+  ],
+  "atoll-tank": [["L27", "vector"]],
+  "atoll-obs": [["L153", "attack-info"]],
+  "widow-baron": [
+    ["L214", "vector"],
+    ["L213", "vector"],
+    ["L212", "vector"],
+    ["L211", "vector"],
+    ["L210", "vector"],
+    ["L209", "vector"],
+    ["L208", "vector"],
+    ["L208", "vector"],
+    ["L207", "vector"],
+    ["L206", "vector"],
+    ["L205", "vector"],
+    ["L204", "vector"],
+    ["L203", "vector"],
+    ["L202", "vector"],
+    ["L201", "vector"],
+    ["L200", "vector"],
+    ["L199", "vector"],
+    ["L198", "vector"],
+    ["L197", "vector"]
+  ],
+  "widow": [
+    ["L543", "uint64", true],
+    ["L538", "uint64", true],
+    ["L542", "uint64", true],
+    ["L541", "uint64", true],
+    ["L540", "uint64", true],
+    ["L537", "uint64", true],
+    ["L539", "uint64", true]
+  ],
+  "spydroid": [
+    ["L191", "attack-info"],
+    ["L190", "attack-info"],
+    ["L179", "vector"],
+    ["L178", "vector"],
+    ["L177", "vector"],
+    ["L176", "vector"],
+    ["L175", "vector"]
+  ],
+  "widow-extras": [
+    ["L238", "vector"],
+    ["L249", "attack-info"],
+    ["L246", "attack-info"]
+  ],
+  "widow2": [
+    ["L85", "vector"],
+    ["L84", "vector"],
+    ["L83", "vector"]
   ]
 }
diff --git a/decompiler/config/jak2/stack_structures.jsonc b/decompiler/config/jak2/stack_structures.jsonc
index 0629cf7093..26468f7b03 100644
--- a/decompiler/config/jak2/stack_structures.jsonc
+++ b/decompiler/config/jak2/stack_structures.jsonc
@@ -1651,5 +1651,87 @@
   ],
   "title-plug-lightning": [
     [16, "vector"]
-  ]
+  ],
+  "(method 25 juicer-shot)": [
+    [16, "vector"],
+    [32, "vector"],
+    [48, "matrix"]
+  ],
+  "(method 142 spyder)": [[16, "vector"]],
+  "(method 185 spyder)": [
+    [640, "vector"],
+    [624, "vector"]
+  ],
+  "(code ambush mantis)": [[16, "vector"]],
+  "(anon-function 8 mantis)": [
+    [64, "collide-query"],
+    [48, "vector"],
+    [32, "vector"],
+    [16, "vector"]
+  ],
+  "(anon-function 15 mantis)": [
+    [48, "collide-query"],
+    [16, "vector"],
+    [32, "vector"]
+  ],
+  "(method 142 mantis)": [[16, "vector"]],
+  "(code turning mammoth)": [
+    [16, "vector"],
+    [48, "vector"]
+  ],
+  "(method 185 mammoth)": [[608, "matrix"]],
+  "mammoth-update-ik": [
+    [576, "vector"],
+    [592, "vector"],
+    [608, "vector"],
+    [624, "vector"],
+    [640, "vector"]
+  ],
+  "(method 184 mammoth)": [
+    [16, "vector"],
+    [48, "vector"],
+    [656, "vector"]
+  ],
+  "(method 55 mammoth)": [[704, ["array", "uint32", 4]]],
+  "mammoth-joint-mod-heel": [
+    [64, "vector"],
+    [48, "vector"]
+  ],
+  "(method 182 flying-spider)": [[48, "vector"]],
+  "(event up nest-switch)": [[16, "event-message-block"]],
+  "widow-handler": [[16, "event-message-block"]],
+  "widow-bomb-slots-full": [[16, ["array", "int32", 8]]],
+  "widow-bomb-launch": [
+    [16, "vector"],
+    [32, "vector"],
+    [48, "vector"],
+    [64, ["array", "float", 1]],
+    [80, ["array", "int32", 8]]
+  ],
+  "widow-give-ammo": [
+    [16, "vector"],
+    [32, "vector"]
+  ],
+  "spydroid-launch": [
+    [16, "event-message-block"],
+    [96, "vector"],
+    [112, "vector"],
+    [128, "matrix3"],
+    [176, "vector"],
+    [192, "vector"],
+    [208, ["array", "int32", 8]]
+  ],
+  "widow-bomb-handler": [[16, "vector"]],
+  "(method 11 widow)": [
+    [16, "vector"],
+    [112, "vector"]
+  ],
+  "(method 46 widow)": [
+    [32, "vector"],
+    [16, "vector"]
+  ],
+  "(method 74 kid)": [[16, "vector"]],
+  "(trans idle vehicle-turret)": [[16, "vector"]],
+  "(anon-function 9 hal3-course)": [[96, "transport-params"]],
+  "(method 17 turret-control)": [[16, "attack-info"]]
 }
diff --git a/decompiler/config/jak2/type_casts.jsonc b/decompiler/config/jak2/type_casts.jsonc
index 27b43f1bec..67c93b60e9 100644
--- a/decompiler/config/jak2/type_casts.jsonc
+++ b/decompiler/config/jak2/type_casts.jsonc
@@ -5905,7 +5905,7 @@
     [16, "a0", "process-focusable"],
     [19, "a0", "process-focusable"]
   ],
-  "(method 10 ginsu)": [[6, "t9", "(function none :behavior part-spawner)"]],
+  "(method 10 ginsu)": [[6, "t9", "(function sparticle-launch-control none)"]],
   "(code victory centurion)": [[30, "v1", "art-joint-anim"]],
   "(code fire centurion)": [
     [22, "a0", "process-focusable"],
@@ -7435,5 +7435,515 @@
   ],
   "title-plug-lightning": [
     [99,  "v1", "title-control"]
-  ]
+  ],
+  "(method 74 yakow)": [
+    [5, "v1", "attack-info"],
+    [7, "v1", "attack-info"]
+  ],
+  "(code idle yakow)": [
+    [19, "v1", "art-joint-anim"],
+    [75, "v1", "art-joint-anim"]
+  ],
+  "(code active yakow)": [
+    [30, "v1", "art-joint-anim"],
+    [123, "v1", "art-joint-anim"],
+    [179, "v1", "art-joint-anim"],
+    [308, "v1", "art-joint-anim"]
+  ],
+  "(code kicked yakow)": [[14, "v1", "art-joint-anim"]],
+  "(method 35 juicer-shot)": [
+    [7, "v1", "matrix"],
+    [11, "v1", "matrix"],
+    [16, "v1", "matrix"],
+    [20, "v1", "matrix"]
+  ],
+  "juicer-proj-move": [[15, "s5", "process-focusable"]],
+  "(method 182 juicer)": [
+    [21, "s3", "process-focusable"],
+    [24, "s3", "process-focusable"]
+  ],
+  "(code active juicer)": [
+    [118, "gp", "art-joint-anim"],
+    [205, "a1", "art-joint-anim"]
+  ],
+  "(code victory juicer)": [[31, "gp", "art-joint-anim"]],
+  "(code notice juicer)": [
+    [23, "a0", "process-focusable"],
+    [24, "a0", "process-focusable"],
+    [27, "a0", "process-focusable"],
+    [83, "a1", "art-joint-anim"]
+  ],
+  "(method 7 juicer)": [
+    [19, "t9", "(function process-focusable int process-focusable)"]
+  ],
+  "(method 184 juicer)": [[4, "v1", "collide-shape-prim-group"]],
+  "(code circling juicer)": [
+    [228, "gp", "art-joint-anim"],
+    [131, "gp", "art-joint-anim"]
+  ],
+  "(code hit juicer)": [[30, "v1", "art-joint-anim"]],
+  "(method 78 juicer)": [
+    [18, "s4", "art-joint-anim"],
+    [66, "s4", "art-joint-anim"]
+  ],
+  "(method 77 juicer)": [
+    [37, "a1", "art-joint-anim"],
+    [113, "s5", "art-joint-anim"],
+    [153, "s4", "art-joint-anim"],
+    [153, "s4", "art-joint-anim"]
+  ],
+  "(code taunt juicer)": [[84, "v1", "art-joint-anim"]],
+  "(code stare juicer)": [[23, "gp", "art-joint-anim"]],
+  "juicer-face-player-post": [
+    [31, "gp", "process-focusable"],
+    [68, "gp", "process-focusable"],
+    [71, "gp", "process-focusable"]
+  ],
+  "(post hostile juicer)": [
+    [13, "a0", "process-focusable"],
+    [16, "a0", "process-focusable"]
+  ],
+  "(method 38 juicer-shot)": [
+    [33, "a0", "process-focusable"],
+    [36, "a0", "process-focusable"]
+  ],
+  "(code attack juicer)": [
+    [14, "v1", "art-joint-anim"],
+    [87, "v1", "art-joint-anim"],
+    [123, "s3", "process-focusable"],
+    [281, "a0", "process-focusable"],
+    [284, "a0", "process-focusable"]
+  ],
+  "(method 25 juicer-shot)": [[131, "a1", "int"]],
+  "(method 7 spyder)": [
+    [31, "t9", "(function process-focusable int process-focusable)"]
+  ],
+  "(code attack spyder)": [
+    [116, "a0", "process-focusable"],
+    [119, "a0", "process-focusable"],
+    [242, "a0", "process-focusable"],
+    [245, "a0", "process-focusable"]
+  ],
+  "spyder-face-player-post": [
+    [22, "a0", "process-focusable"],
+    [25, "a0", "process-focusable"],
+    [40, "gp", "process-focusable"],
+    [44, "a0", "process-focusable"],
+    [43, "gp", "process-focusable"],
+    [21, "gp", "process-focusable"]
+  ],
+  "(method 87 spyder)": [[52, "s5", "art-joint-anim"]],
+  "(method 78 spyder)": [[15, "a1", "art-joint-anim"]],
+  "(method 181 spyder)": [
+    [17, "a0", "process-focusable"],
+    [20, "a0", "process-focusable"]
+  ],
+  "(method 31 spyder-shot)": [[7, "t9", "(function projectile none)"]],
+  "(code backup spyder)": [[22, "v1", "art-joint-anim"]],
+  "(trans hostile spyder)": [
+    [20, "a0", "process-focusable"],
+    [23, "a0", "process-focusable"]
+  ],
+  "(method 115 spyder)": [[117, "v1", "int"]],
+  "(code active sniper)": [[30, "v1", "art-joint-anim"]],
+  "(method 88 mantis)": [[20, "a1", "art-joint-anim"]],
+  "(method 87 mantis)": [[16, "a1", "art-joint-anim"]],
+  "(method 89 mantis)": [[16, "a1", "art-joint-anim"]],
+  "(trans active mantis)": [[4, "v0", "(state enemy)"]],
+  "(code active mantis)": [
+    [79, "v1", "art-joint-anim"],
+    [195, "v1", "art-joint-anim"],
+    [139, "v1", "art-joint-anim"],
+    [23, "v1", "art-joint-anim"]
+  ],
+  "(code ambush-crawling mantis)": [[23, "v1", "art-joint-anim"]],
+  "(code ambush-jumping mantis)": [
+    [14, "v1", "art-joint-anim"],
+    [161, "v1", "art-joint-anim"]
+  ],
+  "(trans hostile mantis)": [
+    [27, "gp", "process-focusable"],
+    [41, "gp", "process-focusable"],
+    [100, "gp", "process-focusable"]
+  ],
+  "(code attack0 mantis)": [
+    [18, "v1", "art-joint-anim"],
+    [90, "v1", "art-joint-anim"]
+  ],
+  "(code roll-right mantis)": [
+    [52, "v1", "art-joint-anim"],
+    [113, "v1", "art-joint-anim"]
+  ],
+  "(code attack1 mantis)": [
+    [19, "v1", "art-joint-anim"],
+    [53, "a0", "process-focusable"],
+    [129, "v1", "art-joint-anim"],
+    [201, "v1", "art-joint-anim"],
+    [56, "a0", "process-focusable"]
+  ],
+  "(code crawl mantis)": [
+    [256, "v1", "art-joint-anim"],
+    [25, "v1", "art-joint-anim"]
+  ],
+  "(code roll-left mantis)": [
+    [53, "v1", "art-joint-anim"],
+    [114, "v1", "art-joint-anim"]
+  ],
+  "(code hop-away mantis)": [
+    [24, "gp", "process-focusable"],
+    [59, "gp", "process-focusable"],
+    [133, "v1", "art-joint-anim"]
+  ],
+  "(method 77 mantis)": [
+    [19, "v1", "art-joint-anim"],
+    [52, "v1", "art-joint-anim"]
+  ],
+  "(method 78 mantis)": [
+    [18, "v1", "art-joint-anim"],
+    [50, "v1", "art-joint-anim"],
+    [83, "v1", "art-joint-anim"]
+  ],
+  "(method 67 mantis)": [
+    [20, "a0", "process-focusable"],
+    [23, "a0", "process-focusable"]
+  ],
+  "(method 188 mantis)": [
+    [21, "s5", "process-focusable"],
+    [36, "a0", "process-focusable"],
+    [38, "a0", "process-focusable"],
+    [35, "s5", "process-focusable"]
+  ],
+  "(method 55 mantis)": [
+    [23, "a0", "process-focusable"],
+    [26, "a0", "process-focusable"]
+  ],
+  "(method 7 mammoth)": [
+    [26, "t9", "(function process-focusable int process-focusable)"]
+  ],
+  "(code waiting mammoth)": [[41, "v1", "art-joint-anim"]],
+  "(code wait-to-walk mammoth)": [[18, "v1", "art-joint-anim"]],
+  "(code walking mammoth)": [[74, "a1", "art-joint-anim"]],
+  "(code walking-attack mammoth)": [
+    [16, "v1", "art-joint-anim"],
+    [72, "v1", "art-joint-anim"]
+  ],
+  "(code turning mammoth)": [
+    [33, "gp", "art-joint-anim"],
+    [106, "v1", "art-joint-anim"],
+    [194, "gp", "art-joint-anim"]
+  ],
+  "(code die mammoth)": [
+    [12, "v1", "art-joint-anim"],
+    [64, "v1", "art-joint-anim"],
+    [116, "v1", "art-joint-anim"]
+  ],
+  "(method 184 mammoth)": [
+    [24, "s3", "mammoth-ik-setup"],
+    [38, "s3", "mammoth-ik-setup"],
+    [107, "s3", "mammoth-ik-setup"]
+  ],
+  "mammoth-leg-ik-callback": [[21, "v1", "float"]],
+  "mammoth-joint-mod-heel": [
+    [5, "v1", "mammoth"],
+    [14, "s0", "mammoth"],
+    [19, "s0", "mammoth"],
+    [3, "v1", "int"]
+  ],
+  "(method 28 flying-spider-shot)": [
+    [27, "t9", "(function projectile projectile-options sound-id)"]
+  ],
+  "(code active flying-spider)": [[10, "v1", "art-joint-anim"]],
+  "(code ambush flying-spider)": [[14, "v1", "art-joint-anim"]],
+  "(code ambush-falling flying-spider)": [
+    [10, "v1", "art-joint-anim"],
+    [86, "v1", "art-joint-anim"]
+  ],
+  "(trans hostile flying-spider)": [
+    [21, "a0", "process-focusable"],
+    [24, "a0", "process-focusable"]
+  ],
+  "(trans turn-to-focus flying-spider)": [
+    [34, "s3", "process-focusable"],
+    [37, "s3", "process-focusable"]
+  ],
+  "(code attack flying-spider)": [[14, "v1", "art-joint-anim"]],
+  "(code attack-fire flying-spider)": [
+    [14, "v1", "art-joint-anim"],
+    [66, "v1", "art-joint-anim"],
+    [118, "v1", "art-joint-anim"],
+    [170, "v1", "art-joint-anim"]
+  ],
+  "(code die flying-spider)": [[30, "v1", "art-joint-anim"]],
+  "(event up nest-switch)": [
+    [4, "v1", "attack-info"],
+    [9, "v1", "attack-info"]
+  ],
+  "(method 77 spyder)": [
+    [14, "v1", "art-joint-anim"],
+    [131, "v1", "art-joint-anim"],
+    [100, "s5", "art-joint-anim"]
+  ],
+  "(method 11 piston)": [
+    [165, "v0", "(pointer float)"],
+    ["_stack_", 64, "res-tag"]
+  ],
+  "(method 11 liftcat)": [
+    [74, "v0", "vector"],
+    [100, "v0", "vector"],
+    ["_stack_", 16, "res-tag"],
+    ["_stack_", 32, "res-tag"]
+  ],
+  "(method 11 atollrotpipe)": [
+    [126, "v0", "(pointer float)"],
+    ["_stack_", 16, "res-tag"]
+  ],
+  "(method 11 atoll-hatch)": [
+    [52, "v1", "art-joint-anim"],
+    [82, "v1", "art-joint-anim"]
+  ],
+  "(method 10 slider)": [[10, "t9", "(function process-drawable none)"]],
+  "(method 7 slider)": [
+    [26, "t9", "(function process-drawable int process-drawable)"]
+  ],
+  "(event idle slider)": [
+    [31, "s3", "process-focusable"],
+    [34, "s3", "process-focusable"]
+  ],
+  "(method 11 turbine)": [
+    ["_stack_", 16, "res-tag"],
+    ["_stack_", 32, "res-tag"]
+  ],
+  "widow-want-stone-talker": [[15, "v1", "float"]],
+  "widow-general-flying-talker": [[15, "v1", "float"]],
+  "widow-launch-droids-talker": [[15, "v1", "float"]],
+  "widow-launch-bombs-talker": [[15, "v1", "float"]],
+  "widow-shoot-gun-talker": [[15, "v1", "float"]],
+  "widow-stone-charge-up-talker": [[15, "v1", "float"]],
+  "widow-after-stone-shot-talker": [[15, "v1", "float"]],
+  "widow-leave-perch-talker": [[15, "v1", "float"]],
+  "widow-damaged-talker": [[11, "v1", "float"]],
+  "widow-handler": [
+    [6, "v1", "attack-info"],
+    [11, "v1", "attack-info"],
+    [16, "v1", "attack-info"],
+    [19, "v1", "attack-info"],
+    [198, "a0", "spydroid"],
+    [200, "a0", "spydroid"],
+    [228, "v1", "hud-widow"]
+  ],
+  "(method 21 baron-pod)": [[36, "v1", "float"]],
+  "widow-common": [
+    [474, "s5", "process-focusable"],
+    [478, "s5", "process-focusable"],
+    [486, "s5", "process-focusable"],
+    [539, "v1", "float"]
+  ],
+  "(method 74 spydroid)": [
+    [62, "s0", "process-drawable"],
+    [87, "s0", "process-drawable"],
+    [110, "s0", "process-drawable"],
+    [181, "v1", "attack-info"],
+    [187, "v1", "attack-info"],
+    [203, "v1", "vector"],
+    [105, "a0", "vector"],
+    [44, "v1", "vector"],
+    [31, "v0", "vector"]
+  ],
+  "(exit hidden widow)": [[63, "v1", "hud-widow"]],
+  "(exit big-reaction-stage-1 widow)": [
+    [13, "v1", "hud-widow"],
+    [15, "v1", "hud-widow"]
+  ],
+  "(trans hover-rise-stage-2 widow)": [[38, "v1", "float"]],
+  "(enter hover-low-stage-2 widow)": [[12, "v1", "float"]],
+  "(exit big-reaction-stage-2 widow)": [
+    [72, "v1", "hud-widow"],
+    [74, "v1", "hud-widow"]
+  ],
+  "(trans hover-big-blast-stage-3 widow)": [["_stack_", 256, "baron-pod"]],
+  "widow-last-bomb-anim": [[82, "v1", "float"]],
+  "widow-cleanup-launch-anim": [
+    [69, "v1", "float"],
+    [257, "v1", "float"]
+  ],
+  "(method 10 spydroid)": [[14, "t9", "(function process-focusable none)"]],
+  "(trans hostile spydroid)": [
+    [29, "a0", "process-focusable"],
+    [32, "a0", "process-focusable"]
+  ],
+  "widow-bomb-launch": [
+    [266, "v1", "float"],
+    [421, "v1", "float"],
+    [450, "v1", "float"],
+    [485, "v1", "float"]
+  ],
+  "widow-give-ammo": [
+    [122, "v1", "collectable"],
+    [124, "v1", "collectable"]
+  ],
+  "(enter idle tomb-boss-firepot)": [[2, "v1", "collide-shape-prim-group"]],
+  "(enter broken tomb-boss-firepot)": [[17, "v1", "art-joint-anim"]],
+  "tomb-boss-firepot-shrink-collision": [
+    [2, "v1", "collide-shape-prim-group"],
+    [7, "v1", "collide-shape-prim-group"]
+  ],
+  "(trans freefall widow-bomb)": [
+    [53, "a0", "collide-shape-moving"],
+    [58, "a0", "collide-shape-moving"]
+  ],
+  "spydroid-launch": [
+    [297, "v1", "float"],
+    [379, "v1", "float"],
+    [408, "v1", "float"],
+    [436, "v1", "float"]
+  ],
+  "widow-bomb-handler": [
+    [23, "s5", "widow"],
+    [19, "s4", "widow"],
+    [151, "v1", "float"]
+  ],
+  "(method 34 widow-bomb)": [
+    ["_stack_", 48, "float"],
+    ["_stack_", 64, "float"]
+  ],
+  "widow-bomb-back-handler": [
+    [13, "s4", "widow"],
+    [107, "v1", "float"]
+  ],
+  "(event idle widow-bomb)": [[77, "v1", "float"]],
+  "(exit idle widow-bomb)": [[15, "v1", "float"]],
+  "(trans idle widow-bomb)": [[262, "v1", "float"]],
+  "(method 10 widow-bomb)": [[42, "t9", "(function process-drawable none)"]],
+  "(method 7 widow-bomb)": [
+    [39, "t9", "(function process-drawable int process-drawable)"]
+  ],
+  "tomb-boss-pillar-shrink-collision": [
+    [2, "v1", "collide-shape-prim-group"],
+    [7, "v1", "collide-shape-prim-group"]
+  ],
+  "(enter broken tomb-boss-pillar)": [[17, "v1", "art-joint-anim"]],
+  "(enter idle tomb-boss-pillar)": [[2, "v1", "collide-shape-prim-group"]],
+  "(method 10 tomb-boss-pillar)": [
+    [14, "t9", "(function process-drawable none)"]
+  ],
+  "(method 7 tomb-boss-pillar)": [
+    [14, "t9", "(function process-drawable int process-drawable)"]
+  ],
+  "(event idle tomb-boss-firepot)": [
+    [10, "gp", "widow-shot"],
+    [15, "v1", "attack-info"],
+    [19, "v1", "attack-info"],
+    [24, "a3", "touching-shapes-entry"]
+  ],
+  "(trans idle tomb-boss-debris)": [["_stack_", 16, "float"]],
+  "(method 46 widow)": [],
+  "(event idle baron-pod)": [[46, "v1", "float"]],
+  "(event idle heart-mar)": [
+    [52, "v1", "float"],
+    [66, "v1", "float"]
+  ],
+  "(method 11 widow)": [[163, "v1", "int"]],
+  "(code hit kid)": [[14, "v1", "art-joint-anim"]],
+  "(code arrested kid)": [
+    [18, "v1", "art-joint-anim"],
+    [84, "v1", "crimson-guard"],
+    [118, "v1", "art-joint-anim"],
+    [86, "v1", "crimson-guard"]
+  ],
+  "(code scared-idle kid)": [[56, "v1", "art-joint-anim"]],
+  "(code waiting-turn kid)": [
+    [37, "s5", "art-joint-anim"],
+    [171, "s4", "art-joint-anim"]
+  ],
+  "(code waiting-idle kid)": [[56, "v1", "art-joint-anim"]],
+  "(method 74 kid)": [
+    [62, "a1", "process"],
+    [77, "v1", "process-drawable"]
+  ],
+  "(method 97 kid)": [[78, "s4", "process-focusable"]],
+  "(method 78 kid)": [[17, "a1", "art-joint-anim"]],
+  "(code arrested kor)": [
+    [25, "v1", "art-joint-anim"],
+    [142, "v1", "crimson-guard"],
+    [144, "v1", "crimson-guard"],
+    [159, "v1", "art-joint-anim"],
+    [219, "v1", "art-joint-anim"]
+  ],
+  "(code scared-idle kor)": [[56, "v1", "art-joint-anim"]],
+  "(code waiting-turn kor)": [
+    [37, "s5", "art-joint-anim"],
+    [187, "s4", "art-joint-anim"]
+  ],
+  "(code waiting-idle kor)": [[56, "v1", "art-joint-anim"]],
+  "(code hit kor)": [[14, "v1", "art-joint-anim"]],
+  "(method 78 kor)": [[17, "a1", "art-joint-anim"]],
+  "(method 97 kor)": [[78, "s4", "process-focusable"]],
+  "(method 74 kor)": [
+    [62, "a1", "process"],
+    [77, "v1", "process-drawable"]
+  ],
+  "(anon-function 0 kid3-course)": [[32, "v1", "kidt-wait-spot"]],
+  "(anon-function 8 kid3-course)": [[26, "v1", "kidt-wait-spot"]],
+  "(anon-function 5 kid3-course)": [[15, "v1", "kidt-wait-spot"]],
+  "(anon-function 2 kid3-course)": [[19, "v1", "kidt-wait-spot"]],
+  "(anon-function 10 kid3-course)": [[26, "v1", "kidt-wait-spot"]],
+  "(anon-function 12 kid3-course)": [[50, "v1", "kidt-wait-spot"]],
+  "(anon-function 0 kor3-course)": [[32, "v1", "kort-wait-spot"]],
+  "(anon-function 2 kor3-course)": [[19, "v1", "kort-wait-spot"]],
+  "(anon-function 5 kor3-course)": [[15, "v1", "kort-wait-spot"]],
+  "(anon-function 8 kor3-course)": [[26, "v1", "kort-wait-spot"]],
+  "(anon-function 10 kor3-course)": [[26, "v1", "kort-wait-spot"]],
+  "(anon-function 12 kor3-course)": [[50, "v1", "kort-wait-spot"]],
+  "(method 196 hal)": [
+    [25, "a0", "bot"],
+    [27, "a0", "bot"]
+  ],
+  "(method 74 hal)": [
+    [22, "v1", "bot"],
+    [72, "s5", "bot"],
+    [117, "s5", "bot"],
+    [124, "a0", "vector"],
+    [18, "a1", "process"]
+  ],
+  "hal-simple-check-too-far": [[25, "v1", "process-drawable"]],
+  "(method 228 hal-help-kid)": [[22, "a0", "traffic-manager"]],
+  "(anon-function 4 hal3-course)": [
+    [25, "v1", "hal3-course"],
+    [138, "v1", "halt-wait-spot"]
+  ],
+  "(anon-function 6 hal3-course)": [
+    [45, "s5", "process-drawable"],
+    [61, "s5", "process-drawable"]
+  ],
+  "(anon-function 7 hal3-course)": [
+    [22, "v1", "process-focusable"],
+    [26, "v1", "process-focusable"],
+    [24, "v1", "process-focusable"],
+    [28, "v1", "process-focusable"],
+    [68, "v1", "halt-wait-spot"]
+  ],
+  "(code leave transport)": [[44, "v1", "art-joint-anim"]],
+  "(code idle transport)": [[29, "v1", "art-joint-anim"]],
+  "(code come-down transport)": [[14, "v1", "art-joint-anim"]],
+  "(trans idle vehicle-turret)": [
+    [45, "gp", "process-focusable"],
+    [57, "gp", "process-focusable"]
+  ],
+  "(method 34 transport)": [[22, "v1", "vehicle-turret"]],
+  "(method 10 transport)": [[10, "t9", "(function process-drawable none)"]],
+  "(method 7 vehicle-turret)": [
+    [14, "t9", "(function process-drawable int process-drawable)"]
+  ],
+  "(method 29 vehicle-turret)": [
+    [14, "s5", "process-drawable"],
+    [26, "s5", "process-drawable"]
+  ],
+  "(anon-function 9 hal3-course)": [[128, "v1", "hal3-course"]],
+  "(anon-function 0 hal3-course)": [[23, "v1", "halt-wait-spot"]],
+  "(anon-function 2 hal3-course)": [[59, "v1", "halt-wait-spot"]],
+  "(anon-function 10 hal3-course)": [[234, "v1", "halt-wait-spot"]],
+  "(anon-function 12 hal3-course)": [[13, "v1", "halt-wait-spot"]],
+  "(anon-function 16 hal3-course)": [[32, "v1", "halt-wait-spot"]],
+  "(anon-function 14 hal3-course)": [[32, "v1", "halt-wait-spot"]],
+  "(anon-function 17 hal3-course)": [[55, "v1", "task-manager"]]
 }
diff --git a/decompiler/config/jak2/var_names.jsonc b/decompiler/config/jak2/var_names.jsonc
index 060947af50..b3d6e6d19d 100644
--- a/decompiler/config/jak2/var_names.jsonc
+++ b/decompiler/config/jak2/var_names.jsonc
@@ -2962,4 +2962,4 @@
       "v1-0": "index"
     }
   }
-}
\ No newline at end of file
+}
diff --git a/decompiler/config/jak2_ntsc_v1.jsonc b/decompiler/config/jak2_ntsc_v1.jsonc
index 74d1631b26..5f4d2d025c 100644
--- a/decompiler/config/jak2_ntsc_v1.jsonc
+++ b/decompiler/config/jak2_ntsc_v1.jsonc
@@ -8,7 +8,7 @@
   // if you want to filter to only some object names.
   // it will make the decompiler much faster.
   "allowed_objects": [],
-  "banned_objects": ["tomb-beetle", "texture-anim-tables"],
+  "banned_objects": ["hal", "tomb-beetle", "texture-anim-tables"],
 
   ////////////////////////////
   // CODE ANALYSIS OPTIONS
diff --git a/decompiler/util/data_decompile.cpp b/decompiler/util/data_decompile.cpp
index 2ee33934fa..cbf464cc2c 100644
--- a/decompiler/util/data_decompile.cpp
+++ b/decompiler/util/data_decompile.cpp
@@ -862,7 +862,9 @@ const std::unordered_map<
           {"ai-task-pool",
            {{"tasks", ArrayFieldDecompMeta(TypeSpec("uint32"),
                                            4,
-                                           ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}}}}}};
+                                           ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}}},
+          {"bot-course", {{"spots", ArrayFieldDecompMeta(TypeSpec("bot-spot"), 32)}}},
+          {"hal3-course", {{"spots", ArrayFieldDecompMeta(TypeSpec("bot-spot"), 32)}}}}}};
 
 goos::Object decompile_structure(const TypeSpec& type,
                                  const DecompilerLabel& label,
diff --git a/goal_src/jak2/engine/ai/enemy-h.gc b/goal_src/jak2/engine/ai/enemy-h.gc
index 8a18f85893..470333a61d 100644
--- a/goal_src/jak2/engine/ai/enemy-h.gc
+++ b/goal_src/jak2/engine/ai/enemy-h.gc
@@ -67,6 +67,7 @@
 (defenum enemy-aware
   :type uint64
   (enemy-aware-0 0)
+  (enemy-aware-1 1)
   (enemy-aware-2 2)
   (enemy-aware-3 3)
   (enemy-aware-4 4)
diff --git a/goal_src/jak2/engine/util/smush-control-h.gc b/goal_src/jak2/engine/util/smush-control-h.gc
index 3d54252380..85d0b67e3f 100644
--- a/goal_src/jak2/engine/util/smush-control-h.gc
+++ b/goal_src/jak2/engine/util/smush-control-h.gc
@@ -16,6 +16,7 @@
    (damp-period float       :offset-assert  24)
    (ticks       float       :offset-assert  28)
    )
+  :pack-me
   :method-count-assert 15
   :size-assert         #x20
   :flag-assert         #xf00000020
@@ -29,6 +30,7 @@
     )
   )
 
+
 (defmethod nonzero-amplitude? smush-control ((obj smush-control))
   (!= (-> obj amp) 0.0)
   )
@@ -113,7 +115,3 @@
     )
   obj
   )
-
-
-
-
diff --git a/goal_src/jak2/game.gp b/goal_src/jak2/game.gp
index 1394266d90..c0e8b72454 100644
--- a/goal_src/jak2/game.gp
+++ b/goal_src/jak2/game.gp
@@ -1702,47 +1702,47 @@
 ;; ;; CTYKORA
 ;; ;;;;;;;;;;;;;;;;;;;;;
 
-;; (cgo "CTYKORA.DGO" "ctykora.gd")
+(cgo "CTYKORA.DGO" "ctykora.gd")
 
-;; (goal-src-sequence
-;;   ""
-;;   :deps ("$OUT/obj/los-control.o")
-;;   "levels/common/ai/ai-task-h.gc"
-;;   "levels/common/ai/bot-h.gc"
-;;   "levels/common/ai/bot.gc"
-;;   "levels/common/ai/bot-states.gc"
-;;   "levels/undefined/hal-h.gc"
-;;   "levels/undefined/hal-task.gc"
-;;   "levels/undefined/hal.gc"
-;;   "levels/city/slums/kor/kid-h.gc"
-;;   "levels/city/slums/kor/kor-h.gc"
-;;   "levels/city/slums/kor/hal3-course.gc"
-;;   "levels/city/slums/kor/kid-task.gc"
-;;   "levels/city/slums/kor/kid.gc"
-;;   "levels/city/slums/kor/kid-states.gc"
-;;   "levels/city/slums/kor/kor-task.gc"
-;;   "levels/city/slums/kor/kor.gc"
-;;   "levels/city/slums/kor/kor-states.gc"
-;;   "levels/city/slums/kor/kid3-course.gc"
-;;   "levels/city/slums/kor/kor3-course.gc"
-;;   )
+(goal-src-sequence
+  ""
+  :deps ("$OUT/obj/los-control.o")
+  ;; "levels/common/ai/ai-task-h.gc"
+  ;; "levels/common/ai/bot-h.gc"
+  ;; "levels/common/ai/bot.gc"
+  ;; "levels/common/ai/bot-states.gc"
+  ;; "levels/undefined/hal-h.gc"
+  ;; "levels/undefined/hal-task.gc"
+  ;; "levels/undefined/hal.gc"
+  "levels/city/slums/kor/kid-h.gc"
+  "levels/city/slums/kor/kor-h.gc"
+  "levels/city/slums/kor/hal3-course.gc"
+  "levels/city/slums/kor/kid-task.gc"
+  "levels/city/slums/kor/kid.gc"
+  "levels/city/slums/kor/kid-states.gc"
+  "levels/city/slums/kor/kor-task.gc"
+  "levels/city/slums/kor/kor.gc"
+  "levels/city/slums/kor/kor-states.gc"
+  "levels/city/slums/kor/kid3-course.gc"
+  "levels/city/slums/kor/kor3-course.gc"
+  )
 
-;; (copy-textures 1451 2727 3224)
+(copy-textures 1451 2727 3224)
 
-;; (copy-gos
-;;   "jak-dark-on+0-ag"
-;;   "daxter-highres-ag"
-;;   "jak-highres-ag"
-;;   "kor-highres-ag"
-;;   "atoll-hellcat-ag"
-;;   "kor-ag"
-;;   "kid-highres-ag"
-;;   "crimson-guard-highres-ag"
-;;   "kid-ag"
-;;   "crimson-guard-lowres-ag"
-;;   "transport-ag"
-;;   "ctykora"
-;;   )
+(copy-gos
+  "jak-dark-on+0-ag"
+  ;; "daxter-highres-ag"
+  ;; "jak-highres-ag"
+  ;; "kor-highres-ag"
+  ;; "atoll-hellcat-ag"
+  "kor-ag"
+  ;; "kid-highres-ag"
+  ;; "crimson-guard-highres-ag"
+  ;; "kid-ag"
+  ;; "crimson-guard-lowres-ag"
+  ;; "transport-ag"
+  "ctykora"
+  )
 
 ;; ;;;;;;;;;;;;;;;;;;;;;
 ;; ;; D3A
@@ -4213,27 +4213,27 @@
 ;; ;; TBO
 ;; ;;;;;;;;;;;;;;;;;;;;;
 
-;; (cgo "TBO.DGO" "tbo.gd")
+(cgo "TBO.DGO" "tbo.gd")
 
-;; (copy-textures 1628 1629 2229 2247)
+(copy-textures 1628 1629 2229 2247)
 
-;; (copy-gos
-;;   "baron-widow+0-ag"
-;;   "tomb-boss-catwalk-ag"
-;;   "tomb-boss-bridge-ag"
-;;   "widow-ag"
-;;   "tomb-boss-pillar-ag"
-;;   "spydroid-ag"
-;;   "baron-pod-ag"
-;;   "tomb-boss-firepot-ag"
-;;   "baron-ag"
-;;   "tomb-boss-debris-ag"
-;;   "heart-mar-ag"
-;;   "widow-bomb-ag"
-;;   "tomb-wing-door-ag"
-;;   "particleman-ag"
-;;   "tombboss-vis"
-;;   )
+(copy-gos
+  "baron-widow+0-ag"
+  "tomb-boss-catwalk-ag"
+  "tomb-boss-bridge-ag"
+  "widow-ag"
+  "tomb-boss-pillar-ag"
+  ;; "spydroid-ag"
+  "baron-pod-ag"
+  "tomb-boss-firepot-ag"
+  "baron-ag"
+  "tomb-boss-debris-ag"
+  "heart-mar-ag"
+  "widow-bomb-ag"
+  ;; "tomb-wing-door-ag"
+  ;; "particleman-ag"
+  "tombboss-vis"
+  )
 
 ;; ;;;;;;;;;;;;;;;;;;;;;
 ;; ;; THR
@@ -4418,16 +4418,16 @@
 ;; ;; TOMBEXT
 ;; ;;;;;;;;;;;;;;;;;;;;;
 
-;; (cgo "TOMBEXT.DGO" "tombext.gd")
+(cgo "TOMBEXT.DGO" "tombext.gd")
 
-;; (copy-textures 2525)
+(copy-textures 2525)
 
-;; (copy-gos
-;;   "daxter-highres-ag"
-;;   "tomb-boss-explode-ag"
-;;   "baron-highres-ag"
-;;   "tombext"
-;;   )
+(copy-gos
+  ;; "daxter-highres-ag"
+  "tomb-boss-explode-ag"
+  ;; "baron-highres-ag"
+  "tombext"
+  )
 
 ;; ;;;;;;;;;;;;;;;;;;;;;
 ;; ;; UNB
diff --git a/goal_src/jak2/levels/atoll/atoll-obs.gc b/goal_src/jak2/levels/atoll/atoll-obs.gc
index ceccbdd4a9..0bea6ebb86 100644
--- a/goal_src/jak2/levels/atoll/atoll-obs.gc
+++ b/goal_src/jak2/levels/atoll/atoll-obs.gc
@@ -7,3 +7,1357 @@
 
 ;; DECOMP BEGINS
 
+(deftype piston (process-focusable)
+  ((sound-trans  vector     :inline :offset-assert 208)
+   (init-height  float              :offset-assert 224)
+   (range-top    float              :offset-assert 228)
+   (range-bottom float              :offset-assert 232)
+   (sound-time   time-frame 2       :offset-assert 240)
+   (sync         sync-eased :inline :offset-assert 256)
+   (piston-id    int32              :offset-assert 300)
+   (looping-id   uint32             :offset-assert 304)
+   )
+  :heap-base #xc0
+  :method-count-assert 31
+  :size-assert         #x134
+  :flag-assert         #x1f00c00134
+  (:methods
+    (idle () _type_ :state 27)
+    (dormant-down () _type_ :state 28)
+    (dormant-up () _type_ :state 29)
+    (running () _type_ :state 30)
+    )
+  )
+
+
+(defskelgroup skel-piston piston piston-lod0-jg piston-idle-ja
+              ((piston-lod0-mg (meters 20)) (piston-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0 -6.1 0 7.8)
+              )
+
+(defstate idle (piston)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as object (case event-type
+                     (('sync)
+                      (-> self sync)
+                      )
+                     )
+            )
+    )
+  :trans (behavior ()
+    (cond
+      ((logtest? (actor-option user17) (-> self fact options))
+       (if (task-complete? *game-info* (game-task atoll-sig))
+           (go-virtual running)
+           (go-virtual dormant-down)
+           )
+       )
+      ((= (-> self piston-id) 1)
+       (cond
+         ((task-complete? *game-info* (game-task atoll-sig))
+          (go-virtual running)
+          )
+         ((task-node-closed? (game-task-node atoll-sig-introduction))
+          (go-virtual dormant-up)
+          )
+         (else
+           (go-virtual dormant-down)
+           )
+         )
+       )
+      (else
+        (go-virtual running)
+        )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior piston) sleep-code)
+  )
+
+(defstate dormant-down (piston)
+  :virtual #t
+  :event (-> (method-of-type piston idle) event)
+  :code (the-as (function none :behavior piston) sleep-code)
+  )
+
+(defstate dormant-up (piston)
+  :virtual #t
+  :event (-> (method-of-type piston idle) event)
+  :enter (behavior ()
+    (let ((f1-1 (- (-> self range-top) (-> self range-bottom))))
+      (set! (-> self root-override trans y) (+ (-> self init-height) (+ (-> self range-bottom) f1-1)))
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior piston) transform-and-sleep)
+  )
+
+(defstate running (piston)
+  :virtual #t
+  :event (-> (method-of-type piston idle) event)
+  :enter (behavior ()
+    (if (logtest? (actor-option user18) (-> self fact options))
+        (set! (-> self sound-time 0) (+ (get-timeframe-offset! (-> self sync) 0) (seconds -0.1)))
+        )
+    (none)
+    )
+  :trans (the-as (function none :behavior piston) rider-trans)
+  :code (the-as (function none :behavior piston) sleep-code)
+  :post (behavior ()
+    (let ((f0-1 (- (-> self range-top) (-> self range-bottom))))
+      (set! (-> self root-override trans y)
+            (+ (-> self init-height) (+ (-> self range-bottom) (get-scaled-val! (-> self sync) f0-1 0)))
+            )
+      )
+    (when (and (logtest? (actor-option user18) (-> self fact options))
+               (< (-> self sound-time 0) (-> self clock frame-counter))
+               )
+      (sound-stop (the-as sound-id (-> self looping-id)))
+      (sound-play "piston-loop" :id (the-as sound-id (-> self looping-id)) :position (-> self sound-trans))
+      (+! (-> self sound-time 0) (the int (* 0.5 (the float (-> self sync period)))))
+      )
+    (rider-post)
+    (none)
+    )
+  )
+
+(defmethod deactivate piston ((obj piston))
+  (sound-stop (the-as sound-id (-> obj looping-id)))
+  ((method-of-type process-focusable deactivate) obj)
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! piston ((obj piston) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (local-vars (sv-64 res-tag))
+  (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 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 29081.6 0.0 31948.8)
+      (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-override) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (set! (-> obj sound-trans quad) (-> obj root-override trans quad))
+  (set! (-> obj root-override trans y) (+ 53248.0 (-> obj root-override trans y)))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-piston" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (logior! (-> obj focus-status) (focus-status ignore))
+  (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))
+        )
+  (set! (-> obj piston-id)
+        (res-lump-value (-> obj entity) 'extra-id int :default (the-as uint128 -1) :time -1000000000.0)
+        )
+  (let ((a1-8 (new 'stack-no-clear 'sync-info-params)))
+    (let ((v1-29 0))
+      (if #t
+          (set! v1-29 (logior v1-29 1))
+          )
+      (set! (-> a1-8 sync-type) 'sync-eased)
+      (set! (-> a1-8 sync-flags) (the-as sync-flags v1-29))
+      )
+    (set! (-> a1-8 period) (the-as uint 1500))
+    (set! (-> a1-8 entity) (-> obj entity))
+    (set! (-> a1-8 percent) 0.0)
+    (set! (-> a1-8 ease-in) 0.15)
+    (set! (-> a1-8 ease-out) 0.15)
+    (set! (-> a1-8 pause-in) 0.0)
+    (set! (-> a1-8 pause-out) 0.0)
+    (initialize! (-> obj sync) a1-8)
+    )
+  (let ((f28-0 -3.0)
+        (f30-0 3.0)
+        )
+    (set! sv-64 (new 'static 'res-tag))
+    (let ((v1-40 (res-lump-data arg0 'move-range (pointer float) :tag-ptr (& sv-64))))
+      (when v1-40
+        (set! f28-0 (-> v1-40 0))
+        (set! f30-0 (-> v1-40 1))
+        )
+      )
+    (set! (-> obj range-bottom) (* 4096.0 f28-0))
+    (set! (-> obj range-top) (* 4096.0 f30-0))
+    )
+  (set! (-> obj init-height) (-> obj root-override trans y))
+  (set! (-> obj root-override trans y) (+ -40960.0 (-> obj root-override trans y)))
+  (cond
+    ((logtest? (actor-option user18) (-> obj fact options))
+     (set! (-> obj looping-id) (the-as uint (new-sound-id)))
+     )
+    (else
+      (set! (-> obj looping-id) (the-as uint 0))
+      0
+      )
+    )
+  (ja-channel-push! 1 0)
+  (let ((a0-26 (-> obj skel root-channel 0)))
+    (set! (-> a0-26 frame-group) (the-as art-joint-anim (-> obj draw art-group data 3)))
+    (set! (-> a0-26 param 0) 1.0)
+    (set! (-> a0-26 frame-num) 0.0)
+    (joint-control-channel-group! a0-26 (the-as art-joint-anim (-> obj draw art-group data 3)) num-func-loop!)
+    )
+  (transform-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(deftype turbine (process-drawable)
+  ((dest-height float   :offset-assert 200)
+   (rise-height float   :offset-assert 204)
+   (rotspeed    float   :offset-assert 208)
+   (risen       symbol  :offset-assert 212)
+   )
+  :heap-base #x60
+  :method-count-assert 22
+  :size-assert         #xd8
+  :flag-assert         #x16006000d8
+  (:methods
+    (idle () _type_ :state 20)
+    (risen () _type_ :state 21)
+    )
+  )
+
+
+(defskelgroup skel-turbine turbine turbine-lod0-jg -1
+              ((turbine-lod0-mg (meters 20)) (turbine-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0 -10 0 14)
+              )
+
+(defstate idle (turbine)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('rise)
+       (go-virtual risen)
+       )
+      )
+    )
+  :trans (behavior ()
+    (if (task-complete? *game-info* (game-task atoll-sig))
+        (go-virtual risen)
+        )
+    (rider-trans)
+    (none)
+    )
+  :code (the-as (function none :behavior turbine) sleep-code)
+  :post (behavior ()
+    (quaternion-rotate-y!
+      (-> self root quat)
+      (-> self root quat)
+      (* (-> self rotspeed) (-> self clock seconds-per-frame))
+      )
+    (let ((f1-2 (- (-> self dest-height) (-> self root trans y))))
+      (if (< 0.0 f1-2)
+          (+! (-> self root trans y) (* (fmax 6144.0 (* 0.5 f1-2)) (-> self clock seconds-per-frame)))
+          )
+      )
+    (update! (-> self sound))
+    (rider-post)
+    (none)
+    )
+  )
+
+(defstate risen (turbine)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self dest-height) (+ (-> self root trans y) (-> self rise-height)))
+    (none)
+    )
+  :trans (the-as (function none :behavior turbine) rider-trans)
+  :code (the-as (function none :behavior turbine) sleep-code)
+  :post (behavior ()
+    (quaternion-rotate-y!
+      (-> self root quat)
+      (-> self root quat)
+      (* (-> self rotspeed) (-> self clock seconds-per-frame))
+      )
+    (let ((f1-2 (- (-> self dest-height) (-> self root trans y))))
+      (if (< 0.0 f1-2)
+          (+! (-> self root trans y) (* (fmax 6144.0 (* 0.5 f1-2)) (-> self clock seconds-per-frame)))
+          )
+      )
+    (update! (-> self sound))
+    (rider-post)
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! turbine ((obj turbine) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (local-vars (sv-16 res-tag) (sv-32 res-tag))
+  (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 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) 0.0 32768.0 0.0 57344.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 root trans y) (+ 73728.0 (-> obj root trans y)))
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-turbine" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj dest-height) (-> obj root trans y))
+  (set! (-> obj risen) #f)
+  (let ((f30-0 8192.0)
+        (f28-0 0.0)
+        )
+    (set! sv-16 (new 'static 'res-tag))
+    (let ((v1-25 (res-lump-data arg0 'rotspeed pointer :tag-ptr (& sv-16))))
+      (if v1-25
+          (set! f30-0 (-> (the-as (pointer float) v1-25)))
+          )
+      )
+    (set! sv-32 (new 'static 'res-tag))
+    (let ((v1-27 (res-lump-data arg0 'rise-height pointer :tag-ptr (& sv-32))))
+      (if v1-27
+          (set! f28-0 (-> (the-as (pointer float) v1-27)))
+          )
+      )
+    (set! (-> obj rotspeed) f30-0)
+    (set! (-> obj rise-height) f28-0)
+    )
+  (set! (-> obj sound)
+        (new 'process 'ambient-sound (static-sound-spec "turbine" :fo-max 50) (-> obj root trans))
+        )
+  (ja-channel-push! 1 0)
+  (let ((a0-19 (-> obj skel root-channel 0)))
+    (set! (-> a0-19 frame-group) (the-as art-joint-anim (-> obj draw art-group data 3)))
+    (set! (-> a0-19 param 0) 1.0)
+    (set! (-> a0-19 frame-num) 0.0)
+    (joint-control-channel-group! a0-19 (the-as art-joint-anim (-> obj draw art-group data 3)) num-func-loop!)
+    )
+  (transform-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(deftype liftcat (process-drawable)
+  ((up-y   float  :offset-assert 200)
+   (down-y float  :offset-assert 204)
+   )
+  :heap-base #x50
+  :method-count-assert 23
+  :size-assert         #xd0
+  :flag-assert         #x17005000d0
+  (:methods
+    (idle-up () _type_ :state 20)
+    (going-down () _type_ :state 21)
+    (idle-down () _type_ :state 22)
+    )
+  )
+
+
+(defskelgroup skel-liftcat liftcat liftcat-lod0-jg liftcat-idle-ja
+              ((liftcat-lod0-mg (meters 20)) (liftcat-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0 -4 0 12.25)
+              )
+
+(defstate idle-up (liftcat)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('ridden 'edge-grabbed)
+       (go-virtual going-down)
+       )
+      (('query)
+       0
+       )
+      )
+    )
+  :trans (the-as (function none :behavior liftcat) rider-trans)
+  :code (the-as (function none :behavior liftcat) sleep-code)
+  :post (the-as (function none :behavior liftcat) rider-post)
+  )
+
+(defstate going-down (liftcat)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as object (case event-type
+                     (('query)
+                      1
+                      )
+                     )
+            )
+    )
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (sound-play "liftcat")
+    (none)
+    )
+  :trans (behavior ()
+    (rider-trans)
+    (let ((gp-0 (-> self root)))
+      (if (>= (-> self down-y) (-> gp-0 trans y))
+          (go-virtual idle-down)
+          )
+      (if (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.5))
+          (set! (-> self root transv y) -8192.0)
+          (set! (-> self root transv y) 0.0)
+          )
+      (vector-v++! (-> gp-0 trans) (-> gp-0 transv))
+      (if (>= (-> self down-y) (-> gp-0 trans y))
+          (set! (-> gp-0 trans y) (-> self down-y))
+          )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior liftcat) sleep-code)
+  :post (the-as (function none :behavior liftcat) rider-post)
+  )
+
+(defstate idle-down (liftcat)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as object (case event-type
+                     (('query)
+                      2
+                      )
+                     )
+            )
+    )
+  :enter (behavior ()
+    (process-entity-status! self (entity-perm-status subtask-complete) #t)
+    (none)
+    )
+  :code (the-as (function none :behavior liftcat) sleep-code)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! liftcat ((obj liftcat) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (local-vars (sv-16 res-tag) (sv-32 res-tag))
+  (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 rideable))
+      (set! (-> s3-0 transform-index) 3)
+      (set-vector! (-> s3-0 local-sphere) 0.0 40960.0 0.0 50176.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)
+  (let ((s4-1 (-> obj root)))
+    (set! sv-16 (new 'static 'res-tag))
+    (let ((v1-15 (res-lump-data arg0 'trans-offset vector :tag-ptr (& sv-16))))
+      (when v1-15
+        (+! (-> s4-1 trans x) (-> v1-15 x))
+        (+! (-> s4-1 trans y) (-> v1-15 y))
+        (+! (-> s4-1 trans z) (-> v1-15 z))
+        )
+      )
+    (set! sv-32 (new 'static 'res-tag))
+    (let ((v1-17 (res-lump-data arg0 'scale-mult vector :tag-ptr (& sv-32))))
+      (when v1-17
+        (set! (-> s4-1 scale x) (* (-> s4-1 scale x) (-> v1-17 x)))
+        (set! (-> s4-1 scale y) (* (-> s4-1 scale y) (-> v1-17 y)))
+        (set! (-> s4-1 scale z) (* (-> s4-1 scale z) (-> v1-17 z)))
+        )
+      )
+    )
+  (set! (-> obj root trans y) (+ 55558.145 (-> obj root trans y)))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-liftcat" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (let ((v1-24 (-> obj root)))
+    (set! (-> obj down-y) (-> v1-24 trans y))
+    (set! (-> v1-24 trans y) (+ 28672.0 (-> v1-24 trans y)))
+    (set! (-> obj up-y) (-> v1-24 trans y))
+    (vector-reset! (-> v1-24 transv))
+    )
+  (ja-channel-set! 1)
+  (let ((s5-2 (-> obj skel root-channel 0)))
+    (joint-control-channel-group-eval!
+      s5-2
+      (the-as art-joint-anim (-> obj draw art-group data 3))
+      num-func-identity
+      )
+    (set! (-> s5-2 frame-num) 0.0)
+    )
+  (if (task-complete? *game-info* (game-task atoll-sig))
+      (process-entity-status! obj (entity-perm-status subtask-complete) #t)
+      )
+  (cond
+    ((and (-> obj entity) (logtest? (-> obj entity extra perm status) (entity-perm-status subtask-complete)))
+     (set! (-> obj root trans y) (-> obj down-y))
+     (transform-post)
+     (go (method-of-object obj idle-down))
+     )
+    (else
+      (set! (-> obj root trans y) (-> obj up-y))
+      (transform-post)
+      (go (method-of-object obj idle-up))
+      )
+    )
+  (none)
+  )
+
+(deftype atollrotpipe (process-drawable)
+  ((root-override collide-shape-moving         :offset 128)
+   (smush         smush-control        :inline :offset 200)
+   (init-quat     quaternion           :inline :offset 240)
+   (rot-angle     float                        :offset 256)
+   (shudder-angle float                        :offset 260)
+   (cycle-time    float                        :offset 264)
+   (cycle-offset  float                        :offset 268)
+   )
+  :heap-base #x90
+  :method-count-assert 21
+  :size-assert         #x110
+  :flag-assert         #x1500900110
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+
+(defskelgroup skel-atollrotpipe atollrotpipe atollrotpipe-lod0-jg -1
+              ((atollrotpipe-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 16)
+              )
+
+(defstate idle (atollrotpipe)
+  :virtual #t
+  :trans (behavior ()
+    (rider-trans)
+    (let ((a1-0 (new 'stack-no-clear 'vector)))
+      (set! (-> a1-0 x) 0.0)
+      (set! (-> a1-0 y) 0.0)
+      (set! (-> a1-0 z) 1.0)
+      (set! (-> a1-0 w) 1.0)
+      (let ((a2-1 (quaternion-vector-angle!
+                    (new 'stack-no-clear 'quaternion)
+                    a1-0
+                    (+ (-> self rot-angle) (-> self shudder-angle))
+                    )
+                  )
+            )
+        (quaternion*! (-> self root-override quat) (-> self init-quat) a2-1)
+        )
+      )
+    (none)
+    )
+  :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)
+          )
+        )
+      (activate! (-> self smush) -1.0 60 225 1.0 1.0 (-> self clock))
+      (sound-play "rot-pipe-wiggle" :position (-> self root-override trans))
+      (let ((gp-3 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-3) (seconds 0.75))
+          (set! (-> self shudder-angle) (* 364.0889 (update! (-> self smush))))
+          (suspend)
+          )
+        )
+      (set! (-> self shudder-angle) 0.0)
+      (set-zero! (-> self smush))
+      (let ((gp-4 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-4) (seconds 0.25))
+          (suspend)
+          )
+        )
+      (sound-play "rot-pipe-turn" :position (-> self root-override trans))
+      (let* ((f0-7 2.0)
+             (f30-1 (* 16384.0 f0-7))
+             (gp-6 (-> self clock frame-counter))
+             )
+        (until (>= (- (-> self clock frame-counter) gp-6) (seconds 0.5))
+          (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 #x4000))
+        (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 ()
+    (rider-post)
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! atollrotpipe ((obj atollrotpipe) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (local-vars (sv-16 res-tag))
+  (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 rideable))
+      (set! (-> s3-0 transform-index) 3)
+      (set-vector! (-> s3-0 local-sphere) 0.0 0.0 0.0 65536.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-override) (the-as collide-shape-moving s4-0))
+    )
+  (set! (-> obj root-override rider-max-momentum) 8192.0)
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-atollrotpipe" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (set! (-> obj rot-angle) 0.0)
+  (set! (-> obj shudder-angle) 0.0)
+  (quaternion-copy! (-> obj init-quat) (-> obj root-override quat))
+  (ja-channel-push! 1 0)
+  (let ((s4-2 (-> obj skel root-channel 0)))
+    (joint-control-channel-group-eval!
+      s4-2
+      (the-as art-joint-anim (-> obj draw art-group data 2))
+      num-func-identity
+      )
+    (set! (-> s4-2 frame-num) 0.0)
+    )
+  (transform-post)
+  (let ((f28-0 4.0)
+        (f30-0 0.0)
+        )
+    (set! sv-16 (new 'static 'res-tag))
+    (let ((v1-29 (res-lump-data arg0 'cycle-speed (pointer float) :tag-ptr (& sv-16))))
+      (when v1-29
+        (set! f28-0 (-> v1-29 0))
+        (set! f30-0 (-> v1-29 1))
+        )
+      )
+    (set! (-> obj cycle-time) (the float (max 0 (+ (the int (* 300.0 f28-0)) -375))))
+    (set! (-> obj cycle-offset) (the float (the int (* 300.0 f30-0))))
+    )
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(deftype slider (process-drawable)
+  ((root-override     collide-shape-moving           :offset        128)
+   (path-pos          float                          :offset-assert 200)
+   (sync              sync-eased           :inline   :offset-assert 208)
+   (attack-id         uint32                         :offset-assert 252)
+   (sound-id          uint32                         :offset-assert 256)
+   (collide-off-timer uint64                         :offset-assert 264)
+   (l-points          vector               6 :inline :offset-assert 272)
+   (l-bolts           lightning-control    4         :offset-assert 368)
+   )
+  :heap-base #x100
+  :method-count-assert 21
+  :size-assert         #x180
+  :flag-assert         #x1501000180
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+
+(defskelgroup skel-slider slider slider-lod0-jg -1
+              ((slider-lod0-mg (meters 20)) (slider-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 7)
+              )
+
+(defstate idle (slider)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as
+      object
+      (case event-type
+        (('touch 'attack)
+         (when (>= (- (-> self clock frame-counter) (the-as int (-> self collide-off-timer))) (seconds 2))
+           (let* ((s4-0 proc)
+                  (s3-0 (if (type? s4-0 process-focusable)
+                            s4-0
+                            )
+                        )
+                  )
+             (when s3-0
+               (let ((s4-1 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override quat))))
+                 (let* ((v1-7 (vector-z-quaternion! (new 'stack-no-clear 'vector) (get-quat (the-as process-focusable s3-0) 0)))
+                        (f0-1 (vector-dot s4-1 v1-7))
+                        )
+                   (if (< 0.0 f0-1)
+                       (vector-float*! s4-1 s4-1 -1.0)
+                       )
+                   )
+                 (sound-play "slide-zap")
+                 (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-or-shove)
+                   (set! (-> a1-8 param 0) (-> event param 0))
+                   (let ((v1-17 (new 'static 'attack-info :mask (attack-info-mask vector shove-back shove-up id))))
+                     (set! (-> v1-17 id) (-> self attack-id))
+                     (set! (-> v1-17 vector quad) (-> s4-1 quad))
+                     (set! (-> v1-17 shove-back) 32768.0)
+                     (set! (-> v1-17 shove-up) 12288.0)
+                     (set! (-> a1-8 param 1) (the-as uint v1-17))
+                     )
+                   (send-event-function proc a1-8)
+                   )
+                 )
+               (let ((v0-0 (-> self clock frame-counter)))
+                 (set! (-> self collide-off-timer) (the-as uint v0-0))
+                 v0-0
+                 )
+               )
+             )
+           )
+         )
+        )
+      )
+    )
+  :code (the-as (function none :behavior slider) sleep-code)
+  :post (behavior ()
+    (let ((f30-0 (get-norm! (-> self sync) 0)))
+      (set! (-> self path-pos) f30-0)
+      (get-point-at-percent-along-path! (-> self path) (-> self root-override trans) (-> self path-pos) 'interp)
+      (let ((f0-3 (sin-rad (* 3.1415925 f30-0))))
+        (update-vol! (-> self sound) (sqrtf f0-3))
+        )
+      )
+    (update-trans! (-> self sound) (-> self root-override trans))
+    (let ((a1-4 (new 'stack-no-clear 'overlaps-others-params)))
+      (set! (-> a1-4 options) (overlaps-others-options oo0))
+      (set! (-> a1-4 collide-with-filter) (the-as collide-spec -1))
+      (set! (-> a1-4 tlist) *touching-list*)
+      (find-overlapping-shapes (-> self root-override) a1-4)
+      )
+    (let ((v1-17 (-> self root-override trans))
+          (a0-6 (-> self l-bolts))
+          (a1-5 (-> self l-points))
+          )
+      (dotimes (a2-1 4)
+        (let* ((t1-0 (if (>= 1 a2-1)
+                         a2-1
+                         (+ a2-1 1)
+                         )
+                     )
+               (t0-1 (vector+! (new 'stack-no-clear 'vector) v1-17 (-> a1-5 t1-0)))
+               (a3-4 (vector+! (new 'stack-no-clear 'vector) v1-17 (-> a1-5 (+ t1-0 1))))
+               )
+          (set! (-> a0-6 a2-1 state meet data 0 quad) (-> t0-1 quad))
+          (let ((t0-5 (-> a0-6 a2-1)))
+            (set! (-> t0-5 state meet data (+ (-> t0-5 state points-to-draw) -1) quad) (-> a3-4 quad))
+            )
+          )
+        )
+      )
+    (sound-play "slide-lightning" :id (the-as sound-id (-> self sound-id)))
+    (update! (-> self sound))
+    (transform-post)
+    (none)
+    )
+  )
+
+(defmethod run-logic? slider ((obj slider))
+  #t
+  )
+
+(defmethod deactivate slider ((obj slider))
+  (sound-stop (the-as sound-id (-> obj sound-id)))
+  ((the-as (function process-drawable none) (find-parent-method slider 10)) obj)
+  (none)
+  )
+
+;; WARN: Return type mismatch process-drawable vs slider.
+(defmethod relocate slider ((obj slider) (arg0 int))
+  (dotimes (v1-0 4)
+    (if (nonzero? (-> obj l-bolts v1-0))
+        (&+! (-> obj l-bolts v1-0) arg0)
+        )
+    )
+  (the-as
+    slider
+    ((the-as (function process-drawable int process-drawable) (find-parent-method slider 7)) obj arg0)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! slider ((obj slider) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum 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 player-list))
+      (set! (-> v1-2 transform-index) 0)
+      (set-vector! (-> v1-2 local-sphere) 0.0 0.0 0.0 28672.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) (the-as collide-shape-moving s4-0))
+    )
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-slider" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (let ((a1-7 (new 'stack-no-clear 'sync-info-params)))
+    (let ((v1-12 0))
+      (if #t
+          (set! v1-12 (logior v1-12 1))
+          )
+      (set! (-> a1-7 sync-type) 'sync-eased)
+      (set! (-> a1-7 sync-flags) (the-as sync-flags v1-12))
+      )
+    (set! (-> a1-7 period) (the-as uint 2400))
+    (set! (-> a1-7 entity) (-> obj entity))
+    (set! (-> a1-7 percent) 0.0)
+    (set! (-> a1-7 ease-in) 0.15)
+    (set! (-> a1-7 ease-out) 0.15)
+    (set! (-> a1-7 pause-in) 0.0)
+    (set! (-> a1-7 pause-out) 0.0)
+    (initialize! (-> obj sync) a1-7)
+    )
+  (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))
+  (set! (-> obj path-pos) 0.0)
+  (let* ((v1-24 *game-info*)
+         (a0-20 (+ (-> v1-24 attack-id) 1))
+         )
+    (set! (-> v1-24 attack-id) a0-20)
+    (set! (-> obj attack-id) a0-20)
+    )
+  (set! (-> obj sound-id) (the-as uint (new-sound-id)))
+  (set! (-> obj collide-off-timer) (the-as uint 0))
+  (set-vector! (-> obj l-points 0) 19660.8 20480.0 1638.4 0.0)
+  (set-vector! (-> obj l-points 1) 0.0 24576.0 1638.4 0.0)
+  (set-vector! (-> obj l-points 2) -19660.8 20480.0 1638.4 0.0)
+  (set-vector! (-> obj l-points 3) 19660.8 20480.0 -1638.4 0.0)
+  (set-vector! (-> obj l-points 4) 0.0 24576.0 -1638.4 0.0)
+  (set-vector! (-> obj l-points 5) -19660.8 20480.0 -1638.4 0.0)
+  (let ((s5-2
+          (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 4096.0
+            :merge-factor 0.5
+            :merge-count 2
+            :radius 3072.0
+            :duration -1.0
+            :sound #f
+            )
+          )
+        (s4-2 (-> obj l-points))
+        (s3-0 (-> obj root-override trans))
+        )
+    (dotimes (s2-0 4)
+      (set! (-> obj l-bolts s2-0) (new 'process 'lightning-control s5-2 obj 0.0))
+      (let* ((a1-10 (if (< s2-0 1)
+                        (+ s2-0 1)
+                        s2-0
+                        )
+                    )
+             (a0-39 (vector+! (new 'stack-no-clear 'vector) s3-0 (-> s4-2 a1-10)))
+             (v1-37 (vector+! (new 'stack-no-clear 'vector) s3-0 (-> s4-2 (+ a1-10 1))))
+             )
+        (set! (-> obj l-bolts s2-0 state meet data 0 quad) (-> a0-39 quad))
+        (let ((a0-43 (-> obj l-bolts s2-0)))
+          (set! (-> a0-43 state meet data (+ (-> a0-43 state points-to-draw) -1) quad) (-> v1-37 quad))
+          )
+        )
+      )
+    )
+  (set! (-> obj sound)
+        (new 'process 'ambient-sound (static-sound-spec "slider" :fo-max 50) (-> obj root-override trans))
+        )
+  (ja-channel-push! 1 0)
+  (let ((s5-3 (-> obj skel root-channel 0)))
+    (joint-control-channel-group-eval!
+      s5-3
+      (the-as art-joint-anim (-> obj draw art-group data 3))
+      num-func-identity
+      )
+    (set! (-> s5-3 frame-num) 0.0)
+    )
+  (transform-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(deftype atoll-windmill (process-drawable)
+  ((sync         sync-linear :inline :offset-assert 200)
+   (blade-normal vector      :inline :offset-assert 224)
+   (orig-quat    quaternion  :inline :offset-assert 240)
+   )
+  :heap-base #x80
+  :method-count-assert 21
+  :size-assert         #x100
+  :flag-assert         #x1500800100
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+
+(defskelgroup skel-atoll-windmill atoll-windmill atoll-windmill-lod0-jg -1
+              ((atoll-windmill-lod0-mg (meters 20))
+               (atoll-windmill-lod1-mg (meters 40))
+               (atoll-windmill-lod2-mg (meters 999999))
+               )
+              :bounds (static-spherem 0 0 0 62)
+              :longest-edge (meters 21.191)
+              )
+
+(defstate idle (atoll-windmill)
+  :virtual #t
+  :code (the-as (function none :behavior atoll-windmill) sleep-code)
+  :post (behavior ()
+    (let ((f0-0 (get-scaled-val! (-> self sync) -65536.0 0)))
+      (quaternion-axis-angle!
+        (-> self root quat)
+        (-> self blade-normal x)
+        (-> self blade-normal y)
+        (-> self blade-normal z)
+        f0-0
+        )
+      )
+    (quaternion*! (-> self root quat) (-> self root quat) (-> self orig-quat))
+    (quaternion-normalize! (-> self root quat))
+    (update! (-> self sound))
+    (ja-post)
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! atoll-windmill ((obj atoll-windmill) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (set! (-> obj mask) (logior (process-mask ambient) (-> obj mask)))
+  (let ((a1-1 (new 'stack-no-clear 'sync-info-params)))
+    (let ((v1-2 0))
+      (if #f
+          (set! v1-2 (logior v1-2 1))
+          )
+      (set! (-> a1-1 sync-type) 'sync-linear)
+      (set! (-> a1-1 sync-flags) (the-as sync-flags v1-2))
+      )
+    (set! (-> a1-1 entity) arg0)
+    (set! (-> a1-1 period) (the-as uint 3000))
+    (set! (-> a1-1 percent) 0.0)
+    (initialize! (-> obj sync) a1-1)
+    )
+  (set! (-> obj root) (new 'process 'trsqv))
+  (process-drawable-from-entity! obj arg0)
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-atoll-windmill" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (quaternion-copy! (-> obj orig-quat) (-> obj root quat))
+  (vector-z-quaternion! (-> obj blade-normal) (-> obj root quat))
+  (vector-normalize! (-> obj blade-normal) 1.0)
+  (set! (-> obj sound)
+        (new 'process 'ambient-sound (static-sound-spec "atoll-windmill" :fo-max 50) (-> obj root trans))
+        )
+  (ja-channel-push! 1 0)
+  (let ((s5-2 (-> obj skel root-channel 0)))
+    (joint-control-channel-group-eval!
+      s5-2
+      (the-as art-joint-anim (-> obj draw art-group data 4))
+      num-func-identity
+      )
+    (set! (-> s5-2 frame-num) 0.0)
+    )
+  (ja-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(deftype atoll-valve (process-drawable)
+  ()
+  :heap-base #x50
+  :method-count-assert 21
+  :size-assert         #xc8
+  :flag-assert         #x15005000c8
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+
+(defskelgroup skel-atoll-valve atoll-valve atoll-valve-lod0-jg atoll-valve-idle-ja
+              ((atoll-valve-lod0-mg (meters 20)) (atoll-valve-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 1)
+              :origin-joint-index 3
+              )
+
+(defstate idle (atoll-valve)
+  :virtual #t
+  :code (the-as (function none :behavior atoll-valve) sleep-code)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! atoll-valve ((obj atoll-valve) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (set! (-> obj mask) (logior (process-mask ambient) (-> obj mask)))
+  (set! (-> obj root) (new 'process 'trsqv))
+  (process-drawable-from-entity! obj arg0)
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-atoll-valve" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (ja-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(deftype atoll-hatch (process-drawable)
+  ()
+  :heap-base #x50
+  :method-count-assert 21
+  :size-assert         #xc8
+  :flag-assert         #x15005000c8
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+
+(defskelgroup skel-atoll-hatch atoll-hatch atoll-hatch-lod0-jg atoll-hatch-idle-ja
+              ((atoll-hatch-lod0-mg (meters 20)) (atoll-hatch-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0.7 0 0 1.1)
+              :origin-joint-index 3
+              )
+
+(defstate idle (atoll-hatch)
+  :virtual #t
+  :code (the-as (function none :behavior atoll-hatch) sleep-code)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! atoll-hatch ((obj atoll-hatch) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (set! (-> obj mask) (logior (process-mask ambient) (-> obj mask)))
+  (set! (-> obj root) (new 'process 'trsqv))
+  (process-drawable-from-entity! obj arg0)
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-atoll-hatch" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (cond
+    ((task-complete? *game-info* (game-task atoll-water))
+     (let ((a0-8 (-> obj skel root-channel 0)))
+       (set! (-> a0-8 frame-group) (the-as art-joint-anim (-> obj draw art-group data 3)))
+       (set! (-> a0-8 param 0)
+             (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 3)) frames num-frames) -1))
+             )
+       (set! (-> a0-8 param 1) 1.0)
+       (set! (-> a0-8 frame-num) 1.0)
+       (joint-control-channel-group! a0-8 (the-as art-joint-anim (-> obj draw art-group data 3)) num-func-seek!)
+       )
+     )
+    (else
+      (let ((a0-9 (-> obj skel root-channel 0)))
+        (set! (-> a0-9 frame-group) (the-as art-joint-anim (-> obj draw art-group data 3)))
+        (set! (-> a0-9 param 0)
+              (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 3)) frames num-frames) -1))
+              )
+        (set! (-> a0-9 param 1) 1.0)
+        (set! (-> a0-9 frame-num) 0.0)
+        (joint-control-channel-group! a0-9 (the-as art-joint-anim (-> obj draw art-group data 3)) num-func-seek!)
+        )
+      )
+    )
+  (ja-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(deftype atoll-hellcat (process-drawable)
+  ()
+  :heap-base #x50
+  :method-count-assert 22
+  :size-assert         #xc8
+  :flag-assert         #x16005000c8
+  (:methods
+    (die-fast () _type_ :state 20)
+    (idle () _type_ :state 21)
+    )
+  )
+
+
+(defstate idle (atoll-hellcat)
+  :virtual #t
+  :code (the-as (function none :behavior atoll-hellcat) sleep-code)
+  )
+
+(defstate die-fast (atoll-hellcat)
+  :virtual #t
+  :code (behavior ()
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! atoll-hellcat ((obj atoll-hellcat) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (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 0.0 0.0 34816.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-atoll-hellcat" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (let ((a1-7 (new 'stack-no-clear 'vector)))
+    (set-vector! a1-7 0.0 19441.436 0.0 1.0)
+    (quaternion-zxy! (-> obj root quat) a1-7)
+    )
+  (transform-post)
+  (if (task-complete? *game-info* (game-task atoll-battle))
+      (go (method-of-object obj die-fast))
+      (go (method-of-object obj idle))
+      )
+  (none)
+  )
+
+(defskelgroup skel-atoll-mar-symbol atoll-mar-symbol atoll-mar-symbol-lod0-jg atoll-mar-symbol-idle-ja
+              ((atoll-mar-symbol-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 0.6)
+              :origin-joint-index 3
+              )
+
+(deftype atoll-mar-symbol (process-drawable)
+  ()
+  :heap-base #x50
+  :method-count-assert 21
+  :size-assert         #xc8
+  :flag-assert         #x15005000c8
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+
+(defstate idle (atoll-mar-symbol)
+  :virtual #t
+  :code (the-as (function none :behavior atoll-mar-symbol) sleep-code)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! atoll-mar-symbol ((obj atoll-mar-symbol) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (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-atoll-mar-symbol" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (ja-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(set-subtask-hook!
+  *game-info*
+  18
+  3
+  (lambda :behavior task-manager
+    ()
+    (local-vars (v1-31 symbol))
+    (set! (-> self data-int32 0) 0)
+    (set! (-> self beep-time) (-> self clock frame-counter))
+    (until #f
+      (when (>= (- (-> self clock frame-counter) (-> self beep-time)) (seconds 40))
+        (let ((v1-7 (logand (-> self data-int32 0) 3)))
+          (cond
+            ((zero? v1-7)
+             (talker-spawn-func (-> *talker-speech* 68) *entity-pool* (target-pos 0) (the-as region #f))
+             )
+            ((= v1-7 1)
+             (talker-spawn-func (-> *talker-speech* 69) *entity-pool* (target-pos 0) (the-as region #f))
+             )
+            ((= v1-7 2)
+             (talker-spawn-func (-> *talker-speech* 70) *entity-pool* (target-pos 0) (the-as region #f))
+             )
+            ((= v1-7 3)
+             (talker-spawn-func (-> *talker-speech* 71) *entity-pool* (target-pos 0) (the-as region #f))
+             )
+            )
+          )
+        (set! (-> self beep-time) (-> self clock frame-counter))
+        (+! (-> self data-int32 0) 1)
+        )
+      (b!
+        (>= (vector-vector-distance (target-pos 0) (-> self info end-sphere)) (-> self info end-sphere r))
+        cfg-20
+        :delay #f
+        )
+      (send-event (handle->process (-> self arrow)) 'leave)
+      (b! #t cfg-36 :delay (nop!))
+      (label cfg-20)
+      (let ((a0-21 (>= (-> self data-int32 0) 4)))
+        (b! (not a0-21) cfg-29 :likely-delay (set! v1-31 a0-21))
+        )
+      (set! v1-31 (not (handle->process (-> self arrow))))
+      (label cfg-29)
+      (when v1-31
+        (let ((gp-5 (new 'stack-no-clear 'task-arrow-params)))
+          (set! (-> gp-5 pos quad) (-> self info end-sphere quad))
+          (quaternion-identity! (-> gp-5 quat))
+          (set! (-> gp-5 flags) (task-arrow-flags))
+          (set! (-> gp-5 map-icon) (the-as uint 15))
+          (set! (-> self arrow) (process->handle (task-arrow-spawn gp-5 (the-as task-arrow self))))
+          )
+        )
+      (label cfg-36)
+      (suspend)
+      )
+    #f
+    )
+  )
diff --git a/goal_src/jak2/levels/atoll/atoll-tank.gc b/goal_src/jak2/levels/atoll/atoll-tank.gc
index f62d858676..3e2d979af2 100644
--- a/goal_src/jak2/levels/atoll/atoll-tank.gc
+++ b/goal_src/jak2/levels/atoll/atoll-tank.gc
@@ -7,3 +7,1835 @@
 
 ;; DECOMP BEGINS
 
+(defpartgroup group-atoll-tank-a-trail
+  :id 318
+  :duration (seconds 0.017)
+  :bounds (static-bspherem 0 0 0 15)
+  :parts ((sp-item 1348) (sp-item 1349))
+  )
+
+(defpart 1348
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 4.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 2) (meters 1) 1.0)
+    (sp-rnd-int-flt spt-rot-z (degrees 0.0) 1 32768.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 128.0 64.0 1.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 24.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.013333334) (meters 0.053333335) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.016666668) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-rnd-flt spt-fade-a -0.032 -0.032 1.0)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 2000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (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)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 0.6) 1.0)
+    )
+  )
+
+(defpart 1349
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 4.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 2) (meters 1) 1.0)
+    (sp-rnd-int-flt spt-rot-z (degrees 0.0) 1 32768.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-rnd-flt spt-a 8.0 24.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.013333334) (meters 0.053333335) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.016666668) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-rnd-flt spt-fade-a -0.032 -0.032 1.0)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 2000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (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)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 0.6) 1.0)
+    )
+  )
+
+(defpartgroup group-atoll-tank-a-ground
+  :id 319
+  :duration (seconds 0.017)
+  :bounds (static-bspherem 0 0 0 15)
+  :parts ((sp-item 1350) (sp-item 1351))
+  )
+
+(defpart 1350
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 4.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 2) (meters 1) 1.0)
+    (sp-rnd-int-flt spt-rot-z (degrees 0.0) 1 32768.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 128.0 64.0 1.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 24.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.013333334) (meters 0.053333335) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.016666668) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-rnd-flt spt-fade-a -0.032 -0.032 1.0)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 2000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-conerot-x (degrees 80.0) (degrees 10.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 0.6) 1.0)
+    )
+  )
+
+(defpart 1351
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 4.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 2) (meters 1) 1.0)
+    (sp-rnd-int-flt spt-rot-z (degrees 0.0) 1 32768.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-rnd-flt spt-a 8.0 24.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.013333334) (meters 0.053333335) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.016666668) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-rnd-flt spt-fade-a -0.032 -0.032 1.0)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 2000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-conerot-x (degrees 80.0) (degrees 10.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 0.6) 1.0)
+    )
+  )
+
+(defpartgroup group-atoll-tank-a-slide
+  :id 320
+  :duration (seconds 0.017)
+  :bounds (static-bspherem 0 0 0 15)
+  :parts ((sp-item 1352) (sp-item 1353))
+  )
+
+(defpart 1352
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 1.0 2.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.5) (meters 0.5) 1.0)
+    (sp-rnd-int-flt spt-rot-z (degrees 0.0) 1 32768.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 128.0 64.0 1.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 24.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0) (meters 0.026666667) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.01) (meters 0.006666667) 1.0)
+    (sp-rnd-flt spt-scalevel-y (meters 0.0033333334) (meters 0.0033333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.032 -0.032 1.0)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 1000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 90.0))
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 0.6) 1.0)
+    )
+  )
+
+(defpart 1353
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 1.0 2.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.5) (meters 0.5) 1.0)
+    (sp-rnd-int-flt spt-rot-z (degrees 0.0) 1 32768.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 64.0 64.0 1.0)
+    (sp-copy-from-other spt-g -1)
+    (sp-copy-from-other spt-b -1)
+    (sp-rnd-flt spt-a 8.0 24.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0) (meters 0.026666667) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.01) (meters 0.006666667) 1.0)
+    (sp-rnd-flt spt-scalevel-y (meters 0.0033333334) (meters 0.0033333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.032 -0.032 1.0)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 1000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 90.0))
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 0.6) 1.0)
+    )
+  )
+
+(defpartgroup group-atoll-tank-intact
+  :id 321
+  :bounds (static-bspherem 0 8 12 24)
+  :parts ((sp-item 1354 :fade-after (meters 100) :falloff-to (meters 120) :period 1260 :length 75)
+    (sp-item 1354 :fade-after (meters 100) :falloff-to (meters 120) :period 770 :length 96)
+    (sp-item 1354 :fade-after (meters 140) :falloff-to (meters 160) :period 936 :length 60)
+    (sp-item 1355 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1356 :fade-after (meters 100) :falloff-to (meters 120) :period 1380 :length 75)
+    (sp-item 1356 :fade-after (meters 100) :falloff-to (meters 120) :period 669 :length 96)
+    (sp-item 1356 :fade-after (meters 140) :falloff-to (meters 160) :period 1036 :length 60)
+    (sp-item 1357 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1358 :fade-after (meters 100) :falloff-to (meters 120) :period 1335 :length 75)
+    (sp-item 1358 :fade-after (meters 100) :falloff-to (meters 120) :period 795 :length 96)
+    (sp-item 1358 :fade-after (meters 140) :falloff-to (meters 160) :period 1199 :length 60)
+    (sp-item 1359 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1360 :fade-after (meters 100) :falloff-to (meters 120) :period 1458 :length 75)
+    (sp-item 1360 :fade-after (meters 100) :falloff-to (meters 120) :period 1537 :length 96)
+    (sp-item 1360 :fade-after (meters 140) :falloff-to (meters 160) :period 922 :length 60)
+    (sp-item 1361 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1362 :fade-after (meters 100) :falloff-to (meters 120) :period 1458 :length 75)
+    (sp-item 1362 :fade-after (meters 100) :falloff-to (meters 120) :period 1537 :length 96)
+    (sp-item 1362 :fade-after (meters 140) :falloff-to (meters 160) :period 922 :length 60)
+    (sp-item 1363 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1364 :fade-after (meters 80) :falloff-to (meters 100))
+    (sp-item 1365 :fade-after (meters 80) :falloff-to (meters 100))
+    (sp-item 1366 :fade-after (meters 80) :falloff-to (meters 100))
+    (sp-item 1367 :fade-after (meters 80) :falloff-to (meters 100))
+    (sp-item 1368 :fade-after (meters 80) :falloff-to (meters 100))
+    (sp-item 1369 :fade-after (meters 80) :falloff-to (meters 100))
+    (sp-item 1370 :fade-after (meters 80) :falloff-to (meters 100))
+    (sp-item 1371 :fade-after (meters 80) :falloff-to (meters 100))
+    (sp-item 1372 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1373 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1374 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1375 :fade-after (meters 100) :falloff-to (meters 100))
+    )
+  )
+
+(defpart 1374
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-rnd-flt spt-num 1.0 3.0 1.0)
+    (sp-flt spt-x (meters -1))
+    (sp-flt spt-y (meters 9.8))
+    (sp-flt spt-z (meters -7))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-omega 6.144)
+    (sp-rnd-flt spt-vel-y (meters 0.13333334) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.21333334 -0.21333334 1.0)
+    (sp-rnd-flt spt-accel-y -13.653334 1.3653333 1.0)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-launchrot-x (degrees -5.0) (degrees 10.0) 1.0)
+    (sp-rnd-flt spt-launchrot-z (degrees -5.0) (degrees 10.0) 1.0)
+    (sp-flt spt-conerot-x (degrees -20.0))
+    (sp-flt spt-conerot-y (degrees 60.0))
+    )
+  )
+
+(defpart 1375
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-rnd-flt spt-num 0.0 1.0 1.0)
+    (sp-flt spt-x (meters -1))
+    (sp-flt spt-y (meters 9.8))
+    (sp-flt spt-z (meters -7))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-omega 6.144)
+    (sp-rnd-flt spt-vel-y (meters 0.1) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.28444445 -0.28444445 1.0)
+    (sp-rnd-flt spt-accel-y -13.653334 1.3653333 1.0)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 450)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-launchrot-x (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-rnd-flt spt-launchrot-z (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-flt spt-conerot-x (degrees -20.0))
+    (sp-flt spt-conerot-y (degrees 60.0))
+    )
+  )
+
+(defpart 1372
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-rnd-flt spt-num 1.0 3.0 1.0)
+    (sp-flt spt-x (meters 2))
+    (sp-flt spt-y (meters 9.4))
+    (sp-flt spt-z (meters 9.2))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-omega 6.144)
+    (sp-rnd-flt spt-vel-y (meters 0.1) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.21333334 -0.21333334 1.0)
+    (sp-rnd-flt spt-accel-y -13.653334 1.3653333 1.0)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-launchrot-x (degrees -5.0) (degrees 10.0) 1.0)
+    (sp-rnd-flt spt-launchrot-z (degrees -5.0) (degrees 10.0) 1.0)
+    (sp-flt spt-conerot-x (degrees 50.000004))
+    (sp-flt spt-conerot-y (degrees 20.0))
+    )
+  )
+
+(defpart 1373
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-rnd-flt spt-num 0.0 1.0 1.0)
+    (sp-flt spt-x (meters 2))
+    (sp-flt spt-y (meters 9.4))
+    (sp-flt spt-z (meters 9.2))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-omega 6.144)
+    (sp-rnd-flt spt-vel-y (meters 0.1) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.28444445 -0.28444445 1.0)
+    (sp-rnd-flt spt-accel-y -13.653334 1.3653333 1.0)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 450)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-launchrot-x (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-rnd-flt spt-launchrot-z (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-flt spt-conerot-x (degrees 50.000004))
+    (sp-flt spt-conerot-y (degrees 20.0))
+    )
+  )
+
+(defpart 1368
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-x (meters 3.5))
+    (sp-flt spt-y (meters 3))
+    (sp-flt spt-z (meters -3.1))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-omega 4.096)
+    (sp-rnd-flt spt-vel-y (meters 0.06666667) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-accel-y -4.7786665 1.0922667 1.0)
+    (sp-flt spt-friction 0.98)
+    (sp-int spt-timer 40)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-flt spt-conerot-x (degrees 150.0))
+    (sp-flt spt-conerot-y (degrees 120.0))
+    )
+  )
+
+(defpart 1369
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-rnd-flt spt-num 0.0 1.0 1.0)
+    (sp-flt spt-x (meters 3.75))
+    (sp-flt spt-y (meters 2.75))
+    (sp-flt spt-z (meters -3.1))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-rnd-flt spt-a 64.0 32.0 1.0)
+    (sp-flt spt-omega 4.096)
+    (sp-rnd-flt spt-vel-y (meters 0.06666667) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.48 -0.48 1.0)
+    (sp-rnd-flt spt-accel-y -4.7786665 1.0922667 1.0)
+    (sp-flt spt-friction 0.98)
+    (sp-int spt-timer 75)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-launchrot-x (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-rnd-flt spt-launchrot-z (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-flt spt-conerot-x (degrees 150.0))
+    (sp-flt spt-conerot-y (degrees 120.0))
+    )
+  )
+
+(defpart 1370
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-x (meters 4.8))
+    (sp-flt spt-y (meters 0))
+    (sp-flt spt-z (meters -3.8))
+    (sp-rnd-flt spt-scale-x (meters 0.075) (meters 0.05) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-rnd-flt spt-a 64.0 64.0 1.0)
+    (sp-flt spt-omega 4.096)
+    (sp-rnd-flt spt-vel-y (meters 0.016666668) (meters 0.033333335) 1.0)
+    (sp-rnd-flt spt-fade-a -0.21333334 -0.21333334 1.0)
+    (sp-rnd-flt spt-accel-y -4.096 -0.68266666 1.0)
+    (sp-flt spt-friction 0.97)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 60.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defpart 1371
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-flt spt-num 4.0)
+    (sp-rnd-flt spt-x (meters 4.8) (meters 0.1) 1.0)
+    (sp-flt spt-y (meters 0))
+    (sp-flt spt-z (meters -3.8))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.05) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-rnd-flt spt-a 64.0 64.0 1.0)
+    (sp-flt spt-omega 4.096)
+    (sp-rnd-flt spt-vel-y (meters 0.016666668) (meters 0.05) 1.0)
+    (sp-flt spt-scalevel-x (meters -0.00016666666))
+    (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 -4.096 -0.68266666 1.0)
+    (sp-flt spt-friction 0.97)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-conerot-x (degrees 20.0) (degrees 60.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 25.000002) (degrees 130.0) 1.0)
+    )
+  )
+
+(defpart 1364
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-x (meters 4.4))
+    (sp-flt spt-y (meters 5.5))
+    (sp-flt spt-z (meters 0.1))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-omega 4.096)
+    (sp-rnd-flt spt-vel-y (meters 0.06666667) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-accel-y -4.7786665 1.0922667 1.0)
+    (sp-flt spt-friction 0.98)
+    (sp-int spt-timer 110)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-flt spt-conerot-x (degrees 130.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+(defpart 1365
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-rnd-flt spt-num 0.0 1.0 1.0)
+    (sp-flt spt-x (meters 4.9))
+    (sp-flt spt-y (meters 5))
+    (sp-flt spt-z (meters 0.1))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-rnd-flt spt-a 64.0 32.0 1.0)
+    (sp-flt spt-omega 4.096)
+    (sp-rnd-flt spt-vel-y (meters 0.06666667) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.48 -0.48 1.0)
+    (sp-rnd-flt spt-accel-y -4.7786665 1.0922667 1.0)
+    (sp-flt spt-friction 0.98)
+    (sp-int spt-timer 200)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-launchrot-x (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-rnd-flt spt-launchrot-z (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-flt spt-conerot-x (degrees 130.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+(defpart 1366
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-x (meters 9.4))
+    (sp-flt spt-y (meters 0))
+    (sp-flt spt-z (meters 0.1))
+    (sp-rnd-flt spt-scale-x (meters 0.075) (meters 0.05) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-rnd-flt spt-a 64.0 64.0 1.0)
+    (sp-flt spt-omega 4.096)
+    (sp-rnd-flt spt-vel-y (meters 0.016666668) (meters 0.033333335) 1.0)
+    (sp-rnd-flt spt-fade-a -0.21333334 -0.21333334 1.0)
+    (sp-rnd-flt spt-accel-y -4.096 -0.68266666 1.0)
+    (sp-flt spt-friction 0.97)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 60.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defpart 1367
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-flt spt-num 4.0)
+    (sp-rnd-flt spt-x (meters 9.3) (meters 0.1) 1.0)
+    (sp-flt spt-y (meters 0))
+    (sp-flt spt-z (meters 0.1))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.05) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-rnd-flt spt-a 64.0 64.0 1.0)
+    (sp-flt spt-omega 4.096)
+    (sp-rnd-flt spt-vel-y (meters 0.016666668) (meters 0.05) 1.0)
+    (sp-flt spt-scalevel-x (meters -0.00016666666))
+    (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 -4.096 -0.68266666 1.0)
+    (sp-flt spt-friction 0.97)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-conerot-x (degrees 40.0) (degrees 40.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 45.0) (degrees 90.0) 1.0)
+    )
+  )
+
+(defpart 1363
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.0 2.0 1.0)
+    (sp-flt spt-x (meters 5.75))
+    (sp-flt spt-y (meters 5.5))
+    (sp-flt spt-z (meters 4.1))
+    (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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 32.0 96.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.02) (meters 0.0033333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.85333335 -0.85333335 1.0)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 20.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+(defpart 1362
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 0.6 1.0)
+    (sp-flt spt-x (meters 5.75))
+    (sp-flt spt-y (meters 5.5))
+    (sp-flt spt-z (meters 4.1))
+    (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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 16.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.053333335) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.16 -0.85333335 1.0)
+    (sp-rnd-flt spt-accel-y 4.096 0.13653333 1.0)
+    (sp-flt spt-friction 0.92)
+    (sp-int spt-timer 300)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 20.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+(defpart 1361
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.0 2.0 1.0)
+    (sp-flt spt-x (meters 6))
+    (sp-flt spt-y (meters 6.5))
+    (sp-flt spt-z (meters -6.1))
+    (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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 32.0 96.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.02) (meters 0.0033333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.85333335 -0.85333335 1.0)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 65.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+(defpart 1360
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 0.6 1.0)
+    (sp-flt spt-x (meters 6))
+    (sp-flt spt-y (meters 6.5))
+    (sp-flt spt-z (meters -6.1))
+    (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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 16.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.053333335) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.16 -0.85333335 1.0)
+    (sp-rnd-flt spt-accel-y 4.096 0.13653333 1.0)
+    (sp-flt spt-friction 0.92)
+    (sp-int spt-timer 300)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 65.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+(defpart 1359
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.0 2.0 1.0)
+    (sp-flt spt-x (meters 6))
+    (sp-flt spt-y (meters 6.25))
+    (sp-flt spt-z (meters -5))
+    (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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 32.0 96.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.02) (meters 0.0033333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.85333335 -0.85333335 1.0)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 135.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+(defpart 1358
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 0.6 1.0)
+    (sp-flt spt-x (meters 6))
+    (sp-flt spt-y (meters 6.25))
+    (sp-flt spt-z (meters -5))
+    (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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 16.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.053333335) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.16 -0.85333335 1.0)
+    (sp-rnd-flt spt-accel-y 4.096 0.13653333 1.0)
+    (sp-flt spt-friction 0.92)
+    (sp-int spt-timer 300)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 135.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+(defpart 1357
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.0 2.0 1.0)
+    (sp-flt spt-x (meters 3.75))
+    (sp-flt spt-y (meters 12.25))
+    (sp-flt spt-z (meters 5))
+    (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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 32.0 96.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.02) (meters 0.0033333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.85333335 -0.85333335 1.0)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees -45.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+(defpart 1356
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 0.6 1.0)
+    (sp-flt spt-x (meters 3.75))
+    (sp-flt spt-y (meters 12.25))
+    (sp-flt spt-z (meters 5))
+    (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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 16.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.053333335) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.16 -0.85333335 1.0)
+    (sp-rnd-flt spt-accel-y 4.096 0.13653333 1.0)
+    (sp-flt spt-friction 0.92)
+    (sp-int spt-timer 300)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees -45.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+(defpart 1355
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.0 2.0 1.0)
+    (sp-flt spt-x (meters 4))
+    (sp-flt spt-y (meters 11.1))
+    (sp-flt spt-z (meters 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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 32.0 96.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.02) (meters 0.0033333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.85333335 -0.85333335 1.0)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 30.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+(defpart 1354
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 0.6 1.0)
+    (sp-flt spt-x (meters 4))
+    (sp-flt spt-y (meters 11.1))
+    (sp-flt spt-z (meters 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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 16.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.053333335) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.16 -0.85333335 1.0)
+    (sp-rnd-flt spt-accel-y 4.096 0.13653333 1.0)
+    (sp-flt spt-friction 0.92)
+    (sp-int spt-timer 300)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 30.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+(defpartgroup group-atoll-tank-aftermath
+  :id 322
+  :bounds (static-bspherem 0 0 0 24)
+  :parts ((sp-item 1376 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1377 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1378 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1379 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1380 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1381 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1382 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1383 :fade-after (meters 100) :falloff-to (meters 100))
+    )
+  )
+
+(defpart 1382
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-rnd-flt spt-num 1.0 3.0 1.0)
+    (sp-flt spt-x (meters -0.5))
+    (sp-flt spt-y (meters 0))
+    (sp-flt spt-z (meters -12))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-omega 6.144)
+    (sp-rnd-flt spt-vel-y (meters 0.13333334) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.21333334 -0.21333334 1.0)
+    (sp-rnd-flt spt-accel-y -13.653334 1.3653333 1.0)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-rnd-flt spt-launchrot-x (degrees -5.0) (degrees 10.0) 1.0)
+    (sp-rnd-flt spt-launchrot-z (degrees -5.0) (degrees 10.0) 1.0)
+    (sp-flt spt-conerot-x (degrees -20.0))
+    (sp-flt spt-conerot-y (degrees 60.0))
+    )
+  )
+
+(defpart 1383
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-rnd-flt spt-num 0.0 1.0 1.0)
+    (sp-flt spt-x (meters -0.5))
+    (sp-flt spt-y (meters 0))
+    (sp-flt spt-z (meters -12))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-omega 6.144)
+    (sp-rnd-flt spt-vel-y (meters 0.1) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.28444445 -0.28444445 1.0)
+    (sp-rnd-flt spt-accel-y -13.653334 1.3653333 1.0)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 450)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-rnd-flt spt-launchrot-x (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-rnd-flt spt-launchrot-z (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-flt spt-conerot-x (degrees -20.0))
+    (sp-flt spt-conerot-y (degrees 60.0))
+    )
+  )
+
+(defpart 1381
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 0.4)
+    (sp-rnd-flt spt-x (meters 18) (meters -1) 1.0)
+    (sp-flt spt-y (meters 0))
+    (sp-rnd-flt spt-z (meters -4) (meters -1) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (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-flt spt-r 192.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.01) (meters 0.01) 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-r -0.64)
+    (sp-flt spt-fade-g -0.32)
+    (sp-flt spt-fade-b -0.32)
+    (sp-rnd-flt spt-fade-a -0.10666667 -0.10666667 1.0)
+    (sp-flt spt-accel-y -0.027306668)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 sp-cpuinfo-flag-14)
+    (sp-int-plain-rnd spt-next-time 150 49 1)
+    (sp-launcher-by-id spt-next-launcher 1384)
+    )
+  )
+
+(defpart 1380
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 0.4)
+    (sp-rnd-flt spt-x (meters 16.5) (meters -1) 1.0)
+    (sp-flt spt-y (meters 2.5))
+    (sp-rnd-flt spt-z (meters -9) (meters -1) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (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-flt spt-r 192.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.006666667) (meters 0.006666667) 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-r -0.64)
+    (sp-flt spt-fade-g -0.32)
+    (sp-flt spt-fade-b -0.32)
+    (sp-rnd-flt spt-fade-a -0.16 -0.16 1.0)
+    (sp-flt spt-accel-y -0.027306668)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 400)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 sp-cpuinfo-flag-14)
+    (sp-int-plain-rnd spt-next-time 150 49 1)
+    (sp-launcher-by-id spt-next-launcher 1384)
+    )
+  )
+
+(defpart 1379
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 0.4)
+    (sp-rnd-flt spt-x (meters 12) (meters -1) 1.0)
+    (sp-flt spt-y (meters 2))
+    (sp-rnd-flt spt-z (meters -8) (meters -1) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (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-flt spt-r 192.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.01) (meters 0.01) 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-r -0.64)
+    (sp-flt spt-fade-g -0.32)
+    (sp-flt spt-fade-b -0.32)
+    (sp-rnd-flt spt-fade-a -0.10666667 -0.10666667 1.0)
+    (sp-flt spt-accel-y -0.027306668)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 sp-cpuinfo-flag-14)
+    (sp-int-plain-rnd spt-next-time 150 49 1)
+    (sp-launcher-by-id spt-next-launcher 1384)
+    )
+  )
+
+(defpart 1378
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 0.4)
+    (sp-rnd-flt spt-x (meters -1) (meters -1) 1.0)
+    (sp-flt spt-y (meters 0))
+    (sp-rnd-flt spt-z (meters 4) (meters -1) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (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-flt spt-r 192.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.006666667) (meters 0.006666667) 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-r -0.64)
+    (sp-flt spt-fade-g -0.32)
+    (sp-flt spt-fade-b -0.32)
+    (sp-rnd-flt spt-fade-a -0.16 -0.16 1.0)
+    (sp-flt spt-accel-y -0.027306668)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 400)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 sp-cpuinfo-flag-14)
+    (sp-int-plain-rnd spt-next-time 150 49 1)
+    (sp-launcher-by-id spt-next-launcher 1384)
+    )
+  )
+
+(defpart 1377
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 0.4)
+    (sp-rnd-flt spt-x (meters 1) (meters -2) 1.0)
+    (sp-flt spt-y (meters 2))
+    (sp-rnd-flt spt-z (meters -9) (meters -2) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 3) (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-flt spt-r 192.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.01) (meters 0.01) 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-r -0.64)
+    (sp-flt spt-fade-g -0.32)
+    (sp-flt spt-fade-b -0.32)
+    (sp-rnd-flt spt-fade-a -0.16 -0.16 1.0)
+    (sp-flt spt-accel-y -0.027306668)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 400)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 sp-cpuinfo-flag-14)
+    (sp-int-plain-rnd spt-next-time 150 49 1)
+    (sp-launcher-by-id spt-next-launcher 1384)
+    )
+  )
+
+(defpart 1376
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 0.4)
+    (sp-rnd-flt spt-x (meters 0) (meters -1) 1.0)
+    (sp-flt spt-y (meters 0))
+    (sp-rnd-flt spt-z (meters -1) (meters -1) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (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-flt spt-r 192.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.01) (meters 0.01) 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-r -0.64)
+    (sp-flt spt-fade-g -0.32)
+    (sp-flt spt-fade-b -0.32)
+    (sp-rnd-flt spt-fade-a -0.10666667 -0.10666667 1.0)
+    (sp-flt spt-accel-y -0.027306668)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 sp-cpuinfo-flag-14)
+    (sp-int-plain-rnd spt-next-time 150 49 1)
+    (sp-launcher-by-id spt-next-launcher 1384)
+    )
+  )
+
+(defpart 1384
+  :init-specs ((sp-flt spt-fade-r 0.0) (sp-flt spt-fade-g 0.0) (sp-flt spt-fade-b 0.0))
+  )
+
+(defpartgroup group-atoll-tank-explosion
+  :id 323
+  :duration (seconds 0.5)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 32)
+  :parts ((sp-item 1385 :fade-after (meters 200) :falloff-to (meters 200) :period 900 :length 25)
+    (sp-item 1386 :period 900 :length 10 :offset 10)
+    (sp-item 1387 :fade-after (meters 120) :falloff-to (meters 120) :period 900 :length 100 :offset 25)
+    (sp-item 1388 :period 900 :length 160)
+    (sp-item 1388 :period 900 :length 100)
+    (sp-item 1388 :period 900 :length 50)
+    (sp-item 1388 :period 900 :length 40)
+    (sp-item 1388 :period 900 :length 30)
+    (sp-item 1388 :period 900 :length 20)
+    (sp-item 1389 :period 900 :length 50 :offset 15)
+    (sp-item 1390 :period 900 :length 5)
+    (sp-item 1391 :period 900 :length 50 :offset 15)
+    )
+  )
+
+(defpart 1388
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-flt spt-num 16.0)
+    (sp-rnd-flt spt-x (meters -2) (meters 4) 1.0)
+    (sp-rnd-flt spt-y (meters -4.5) (meters 5) 1.0)
+    (sp-rnd-flt spt-z (meters -2) (meters 4) 1.0)
+    (sp-flt spt-scale-x (meters 2.5))
+    (sp-int spt-rot-x 4)
+    (sp-rnd-flt spt-scale-y (meters 0.1) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.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.13333334) (meters 0.06666667) 1.0)
+    (sp-rnd-flt spt-accel-y -13.653334 -1.3653333 1.0)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-rnd-flt spt-conerot-x (degrees 20.0) (degrees 70.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 45.0) (degrees 90.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 10) 1.0)
+    )
+  )
+
+(defpart 1391
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x34 :page #xc))
+    (sp-rnd-flt spt-num 5.0 5.0 1.0)
+    (sp-flt spt-y (meters -2.5))
+    (sp-rnd-flt spt-scale-x (meters 3) (meters 2) 1.0)
+    (sp-int spt-rot-x 4)
+    (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 8) (meters 4) 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 0.0 32.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.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-rnd-flt spt-friction 0.89 0.02 1.0)
+    (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 30 9 1)
+    (sp-launcher-by-id spt-next-launcher 1392)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-conerot-x)
+      :flags (sp-flag from-pointer)
+      :func '*sp-temp*
+      )
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 2) 1.0)
+    )
+  )
+
+(defpart 1389
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x33 :page #xc))
+    (sp-rnd-flt spt-num 7.0 10.0 1.0)
+    (sp-flt spt-y (meters -2.5))
+    (sp-rnd-flt spt-scale-x (meters 3) (meters 2) 1.0)
+    (sp-flt spt-rot-z (degrees 0.0))
+    (sp-rnd-flt spt-scale-y (meters 6.8) (meters 1.2) 1.0)
+    (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) (meters 0.13333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.06666667) (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.94)
+    (sp-int spt-timer 1000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int-plain-rnd spt-next-time 30 9 1)
+    (sp-launcher-by-id spt-next-launcher 1392)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 8) 1.0)
+    )
+  )
+
+(defpart 1392
+  :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 1393)
+    )
+  )
+
+(defpart 1393
+  :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 1394)
+    )
+  )
+
+(defpart 1394
+  :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 1395)
+    )
+  )
+
+(defpart 1395
+  :init-specs ((sp-flt spt-fade-r 0.0) (sp-flt spt-fade-g 0.0) (sp-flt spt-fade-b 0.0))
+  )
+
+(defpart 1390
+  :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 -2.5))
+    (sp-flt spt-scale-x (meters 32))
+    (sp-flt spt-rot-x 4096.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 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 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 1396)
+    )
+  )
+
+(defpart 1396
+  :init-specs ((sp-flt spt-scalevel-x (meters -0.2857143))
+    (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 1387
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x32 :page #xc))
+    (sp-rnd-flt spt-num 6.0 8.0 1.0)
+    (sp-flt spt-x (meters 0.25))
+    (sp-flt spt-y (meters -2.5))
+    (sp-rnd-flt spt-scale-x (meters 3) (meters 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-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.13333334) (meters 0.26666668) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.008333334) (meters 0.0033333334) 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 -1.3653333 -4.096 1.0)
+    (sp-rnd-flt spt-friction 0.88 0.02 1.0)
+    (sp-int spt-timer 3000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int-plain-rnd spt-next-time 35 14 1)
+    (sp-launcher-by-id spt-next-launcher 1397)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 3) (meters 5) 1.0)
+    )
+  )
+
+(defpart 1397
+  :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 1398)
+    )
+  )
+
+(defpart 1398
+  :init-specs ((sp-flt spt-fade-r -0.5543478) (sp-flt spt-fade-g -0.5543478) (sp-flt spt-fade-a -0.13913043))
+  )
+
+(defpart 1385
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 4.0 8.0 1.0)
+    (sp-rnd-flt spt-x (meters 0) (meters 0.6) 1.0)
+    (sp-flt spt-y (meters -2.5))
+    (sp-rnd-flt spt-scale-x (meters 8.5) (meters 8) 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.2) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.033333335) (meters 0.086666666) 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.89)
+    (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 1399)
+    (sp-rnd-flt spt-conerot-x (degrees -1440.0) (degrees 2880.0) 1.0)
+    )
+  )
+
+(defpart 1399
+  :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 1400)
+    )
+  )
+
+(defpart 1400
+  :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 1386
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x31 :page #xc))
+    (sp-flt spt-num 9.0)
+    (sp-flt spt-y (meters -2.5))
+    (sp-rnd-flt spt-scale-x (meters 2) (meters 6) 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.5) (meters 0.5) 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.1) (meters 0.2) 1.0)
+    (sp-flt spt-fade-g 0.4)
+    (sp-flt spt-fade-b 0.8)
+    (sp-flt spt-fade-a -0.512)
+    (sp-int spt-timer 250)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int spt-next-time 180)
+    (sp-launcher-by-id spt-next-launcher 1401)
+    )
+  )
+
+(defpart 1401
+  :init-specs ((sp-flt spt-fade-r 0.0) (sp-flt spt-fade-g 0.0) (sp-flt spt-fade-b 0.0))
+  )
+
+(defpartgroup group-atoll-tank-splash
+  :id 324
+  :flags (screen-space)
+  :bounds (static-bspherem 0 0 0 16)
+  :parts ((sp-item 1406 :binding 1402)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1407 :binding 1404)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    )
+  )
+
+(defpart 1407
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x29 :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-x (meters -4.5) (meters 9) 1.0)
+    (sp-rnd-flt spt-y (meters -3) (meters 6) 1.0)
+    (sp-flt spt-scale-x (meters 2.5))
+    (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 128.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (sp-flt spt-a 24.0)
+    (sp-flt spt-scalevel-x (meters 0.16666667))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -1.6)
+    (sp-int spt-timer 10)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-14)
+    )
+  )
+
+(defpart 1404
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-scale-x (meters 1.5))
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 128.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 255.0)
+    (sp-flt spt-a 20.0)
+    (sp-flt spt-scalevel-x (meters 0.033333335))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -0.8)
+    (sp-flt spt-accel-y -2.7306666)
+    (sp-int spt-timer 270)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-14)
+    (sp-int spt-next-time 15)
+    (sp-launcher-by-id spt-next-launcher 1408)
+    )
+  )
+
+(defpart 1408
+  :init-specs ((sp-flt spt-scalevel-x (meters 0.004166667))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -0.06666667)
+    )
+  )
+
+(defpart 1405
+  :init-specs ((sp-flt spt-num 1.0)
+    (sp-int spt-rot-x 12)
+    (sp-flt spt-r 4096.0)
+    (sp-flt spt-g 3276.8)
+    (sp-flt spt-b 3276.8)
+    (sp-flt spt-fade-r 6.068148)
+    (sp-flt spt-fade-g 68.26667)
+    (sp-flt spt-fade-b 3.034074)
+    (sp-flt spt-accel-y -2.7306666)
+    (sp-int spt-timer 270)
+    (sp-cpuinfo-flags distort)
+    (sp-int spt-next-time 30)
+    (sp-launcher-by-id spt-next-launcher 1409)
+    )
+  )
+
+(defpart 1409
+  :init-specs ((sp-flt spt-fade-g -5.1200004))
+  )
+
+(defpart 1406
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x29 :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-x (meters -4.5) (meters 9) 1.0)
+    (sp-rnd-flt spt-y (meters -3) (meters 6) 1.0)
+    (sp-flt spt-scale-x (meters 4))
+    (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 128.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (sp-flt spt-a 24.0)
+    (sp-flt spt-scalevel-x (meters 0.26666668))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -1.6)
+    (sp-int spt-timer 10)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-14)
+    )
+  )
+
+(defpart 1402
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-scale-x (meters 2.6))
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 128.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 255.0)
+    (sp-flt spt-a 20.0)
+    (sp-flt spt-scalevel-x (meters 0.06666667))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -0.8)
+    (sp-flt spt-accel-y -2.7306666)
+    (sp-int spt-timer 270)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-14)
+    (sp-int spt-next-time 15)
+    (sp-launcher-by-id spt-next-launcher 1410)
+    )
+  )
+
+(defpart 1410
+  :init-specs ((sp-flt spt-scalevel-x (meters 0.008333334))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -0.06666667)
+    )
+  )
+
+(defpart 1403
+  :init-specs ((sp-flt spt-num 1.0)
+    (sp-int spt-rot-x 24)
+    (sp-flt spt-r 12288.0)
+    (sp-flt spt-g 6553.6)
+    (sp-flt spt-b 6553.6)
+    (sp-flt spt-fade-r 12.136296)
+    (sp-flt spt-fade-g 136.53334)
+    (sp-flt spt-fade-b 6.068148)
+    (sp-flt spt-accel-y -2.7306666)
+    (sp-int spt-timer 270)
+    (sp-cpuinfo-flags distort)
+    (sp-int spt-next-time 30)
+    (sp-launcher-by-id spt-next-launcher 1411)
+    )
+  )
+
+(defpart 1411
+  :init-specs ((sp-flt spt-fade-g -10.240001))
+  )
+
+(defskelgroup skel-atoll-tank-a-debris atoll-tank atoll-tank-a-lod0-jg -1
+              ((atoll-tank-a-lod0-mg (meters 999999)))
+              :bounds (static-spherem 30 -15 13 57)
+              )
+
+(defskelgroup skel-atoll-tank-b-debris atoll-tank atoll-tank-b-lod0-jg -1
+              ((atoll-tank-b-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -10 -5 32)
+              )
+
+(defskelgroup skel-atoll-tank-c-debris atoll-tank atoll-tank-c-lod0-jg -1
+              ((atoll-tank-c-lod0-mg (meters 999999)))
+              :bounds (static-spherem 30 -15 26 66)
+              )
+
+(deftype atoll-tank (process-focusable)
+  ((is-master?     symbol                    :offset-assert 204)
+   (aftermath-part sparticle-launch-control  :offset-assert 208)
+   )
+  :heap-base #x60
+  :method-count-assert 29
+  :size-assert         #xd4
+  :flag-assert         #x1d006000d4
+  (:methods
+    (dormant () _type_ :state 27)
+    (idle () _type_ :state 28)
+    )
+  )
+
+
+(defmethod deactivate atoll-tank ((obj atoll-tank))
+  (if (nonzero? (-> obj aftermath-part))
+      (kill-and-free-particles (-> obj aftermath-part))
+      )
+  ((method-of-type process-focusable deactivate) obj)
+  (none)
+  )
+
+;; WARN: Return type mismatch process-focusable vs atoll-tank.
+(defmethod relocate atoll-tank ((obj atoll-tank) (arg0 int))
+  (if (nonzero? (-> obj aftermath-part))
+      (&+! (-> obj aftermath-part) arg0)
+      )
+  (the-as atoll-tank ((method-of-type process-focusable relocate) obj arg0))
+  )
+
+(defmethod run-logic? atoll-tank ((obj atoll-tank))
+  #t
+  )
+
+(defmethod get-trans atoll-tank ((obj atoll-tank) (arg0 int))
+  "@returns the `trans` [[vector]] from the process's `root` (typically either a [[trsqv]] or a [[collide-shape]])"
+  (let ((v1-0 (-> obj root-override)))
+    (case arg0
+      ((3 2)
+       (let ((v0-0 (new 'static 'vector :w 1.0)))
+         (set! (-> v0-0 quad) (-> v1-0 trans quad))
+         (set! (-> v0-0 y) (+ 12288.0 (-> v0-0 y)))
+         v0-0
+         )
+       )
+      (else
+        (-> v1-0 trans)
+        )
+      )
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior atoll-tank-init-by-other atoll-tank ((arg0 process-drawable) (arg1 int))
+  (set! (-> self is-master?) #f)
+  (set! (-> self root-override) (the-as collide-shape (new 'process 'trsqv)))
+  (let ((s4-0 (-> self root-override)))
+    (set! (-> s4-0 trans quad) (-> arg0 root trans quad))
+    (quaternion-copy! (-> s4-0 quat) (-> arg0 root quat))
+    (vector-identity! (-> s4-0 scale))
+    )
+  (logior! (-> self focus-status) (focus-status ignore))
+  (cond
+    ((= arg1 1)
+     (initialize-skeleton
+       self
+       (the-as
+         skeleton-group
+         (art-group-get-by-name *level* "skel-atoll-tank-b-debris" (the-as (pointer uint32) #f))
+         )
+       (the-as pair 0)
+       )
+     (ja-channel-set! 1)
+     (ja :group! atoll-tank-b-debris-ja :num! min)
+     (setup-masks (-> self draw) 0 2)
+     )
+    (else
+      (initialize-skeleton
+        self
+        (the-as
+          skeleton-group
+          (art-group-get-by-name *level* "skel-atoll-tank-c-debris" (the-as (pointer uint32) #f))
+          )
+        (the-as pair 0)
+        )
+      (ja-channel-set! 1)
+      (ja :group! atoll-tank-c-debris-ja :num! min)
+      (setup-masks (-> self draw) 0 2)
+      )
+    )
+  (ja-post)
+  (go-virtual idle)
+  (none)
+  )
+
+(defstate dormant (atoll-tank)
+  :virtual #t
+  :code (the-as (function none :behavior atoll-tank) sleep-code)
+  )
+
+(defstate idle (atoll-tank)
+  :virtual #t
+  :trans (behavior ()
+    (if (-> self is-master?)
+        (spawn (-> self aftermath-part) (-> self root-override trans))
+        )
+    (none)
+    )
+  :code (behavior ()
+    (when (-> self is-master?)
+      (process-spawn atoll-tank self 1 :to self)
+      (process-spawn atoll-tank self 2 :to self)
+      )
+    (sleep-code)
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! atoll-tank ((obj atoll-tank) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (set! (-> obj is-master?) #t)
+  (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 9) 0)))
+      (set! (-> s4-0 total-prims) (the-as uint 10))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> s3-0 prim-core action) (collide-action solid))
+      (set! (-> s3-0 transform-index) 2)
+      (set-vector! (-> s3-0 local-sphere) 163840.0 0.0 102400.0 278528.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (let ((v1-9 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-9 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-9 prim-core action) (collide-action solid))
+      (set! (-> v1-9 transform-index) 2)
+      (set-vector! (-> v1-9 local-sphere) 4096.0 0.0 -24576.0 59392.0)
+      )
+    (let ((v1-11 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-11 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-11 prim-core action) (collide-action solid))
+      (set! (-> v1-11 transform-index) 2)
+      (set-vector! (-> v1-11 local-sphere) 55296.0 1228.8 -28672.0 34816.0)
+      )
+    (let ((v1-13 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 2) (the-as uint 0))))
+      (set! (-> v1-13 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-13 prim-core action) (collide-action solid))
+      (set! (-> v1-13 transform-index) 2)
+      (set-vector! (-> v1-13 local-sphere) 131072.0 0.0 20480.0 57344.0)
+      )
+    (let ((v1-15 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 3) (the-as uint 0))))
+      (set! (-> v1-15 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-15 prim-core action) (collide-action solid))
+      (set! (-> v1-15 transform-index) 2)
+      (set-vector! (-> v1-15 local-sphere) 221184.0 -45056.0 303104.0 40960.0)
+      )
+    (let ((v1-17 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 4) (the-as uint 0))))
+      (set! (-> v1-17 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-17 prim-core action) (collide-action solid))
+      (set! (-> v1-17 transform-index) 2)
+      (set-vector! (-> v1-17 local-sphere) 204800.0 -57344.0 40960.0 12288.0)
+      )
+    (let ((v1-19 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 5) (the-as uint 0))))
+      (set! (-> v1-19 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-19 prim-core action) (collide-action solid))
+      (set! (-> v1-19 transform-index) 2)
+      (set-vector! (-> v1-19 local-sphere) 280576.0 -57344.0 133120.0 24576.0)
+      )
+    (let ((v1-21 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 6) (the-as uint 0))))
+      (set! (-> v1-21 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-21 prim-core action) (collide-action solid))
+      (set! (-> v1-21 transform-index) 2)
+      (set-vector! (-> v1-21 local-sphere) 194560.0 -57344.0 155648.0 32768.0)
+      )
+    (let ((v1-23 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 7) (the-as uint 0))))
+      (set! (-> v1-23 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-23 prim-core action) (collide-action solid))
+      (set! (-> v1-23 transform-index) 2)
+      (set-vector! (-> v1-23 local-sphere) 73728.0 -57344.0 81920.0 32768.0)
+      )
+    (let ((v1-25 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 8) (the-as uint 0))))
+      (set! (-> v1-25 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-25 prim-core action) (collide-action solid))
+      (set! (-> v1-25 transform-index) 2)
+      (set-vector! (-> v1-25 local-sphere) -28672.0 -57344.0 86016.0 34816.0)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-28 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-28 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-28 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-atoll-tank-a-debris" (the-as (pointer uint32) #f))
+      )
+    (the-as pair 0)
+    )
+  (logior! (-> obj focus-status) (focus-status ignore))
+  (ja-channel-set! 1)
+  (let ((s5-2 (-> obj skel root-channel 0)))
+    (joint-control-channel-group-eval!
+      s5-2
+      (the-as art-joint-anim (-> obj draw art-group data 2))
+      num-func-identity
+      )
+    (set! (-> s5-2 frame-num) 0.0)
+    )
+  (transform-post)
+  (setup-masks (-> obj draw) 0 2)
+  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 321) obj))
+  (set! (-> obj aftermath-part) (create-launch-control (-> *part-group-id-table* 322) obj))
+  (cond
+    ((task-node-closed? (game-task-node atoll-sig-tank))
+     (go (method-of-object obj idle))
+     )
+    (else
+      (logior! (-> obj draw status) (draw-control-status no-draw))
+      (let ((v1-54 (-> obj root-override root-prim)))
+        (set! (-> v1-54 prim-core collide-as) (collide-spec))
+        (set! (-> v1-54 prim-core collide-with) (collide-spec))
+        )
+      (set! (-> obj root-override backup-collide-as) (collide-spec))
+      (set! (-> obj root-override backup-collide-with) (collide-spec))
+      0
+      (go (method-of-object obj dormant))
+      )
+    )
+  (none)
+  )
diff --git a/goal_src/jak2/levels/atoll/juicer.gc b/goal_src/jak2/levels/atoll/juicer.gc
index 9cedb33786..13296de38b 100644
--- a/goal_src/jak2/levels/atoll/juicer.gc
+++ b/goal_src/jak2/levels/atoll/juicer.gc
@@ -5,5 +5,1848 @@
 ;; name in dgo: juicer
 ;; dgos: ATE, CTYASHA
 
+(declare-type juicer nav-enemy)
+
 ;; DECOMP BEGINS
 
+(defpartgroup group-juicer-shot-hit
+  :id 1061
+  :duration (seconds 0.017)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 8)
+  :parts ((sp-item 4633))
+  )
+
+(defpart 4633
+  :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 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 96.0 64.0 1.0)
+    (sp-rnd-flt spt-g 64.0 32.0 1.0)
+    (sp-rnd-flt spt-b 96.0 64.0 1.0)
+    (sp-flt spt-a 64.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-flt spt-fade-r -0.35555556)
+    (sp-flt spt-fade-g -0.35555556)
+    (sp-flt spt-fade-b 0.0)
+    (sp-flt spt-fade-a -0.30476192)
+    (sp-rnd-flt spt-accel-y -0.68266666 0.68266666 1.0)
+    (sp-int spt-timer 210)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int spt-next-time 60)
+    (sp-launcher-by-id spt-next-launcher 4634)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 180.0) 1.0)
+    )
+  )
+
+(defpart 4635
+  :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 3.5))
+    (sp-flt spt-rot-x 409.6)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 0.0)
+    (sp-flt spt-b 0.0)
+    (sp-flt spt-a 16.0)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 819.2)
+    )
+  )
+
+(defpart 4636
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xca :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1.5) (meters 1) 1.0)
+    (sp-flt spt-rot-x 409.6)
+    (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 0.0)
+    (sp-flt spt-b 0.0)
+    (sp-rnd-flt spt-a 48.0 16.0 1.0)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 819.2)
+    )
+  )
+
+(defpart 4637
+  :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 1.5) (meters 0.5) 1.0)
+    (sp-flt spt-rot-x 409.6)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 16.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 0.0)
+    (sp-flt spt-b 0.0)
+    (sp-rnd-flt spt-a 16.0 16.0 1.0)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 819.2)
+    )
+  )
+
+(defpart 4638
+  :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.2) 1.0)
+    (sp-flt spt-rot-x 409.6)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-rnd-flt spt-g 196.0 128.0 1.0)
+    (sp-rnd-flt spt-b 64.0 64.0 1.0)
+    (sp-rnd-flt spt-a 32.0 16.0 1.0)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 819.2)
+    )
+  )
+
+(deftype juicer-shot (projectile)
+  ((lightning lightning-control 5 :offset-assert 472)
+   (victim    handle              :offset-assert 496)
+   )
+  :heap-base #x180
+  :method-count-assert 40
+  :size-assert         #x1f8
+  :flag-assert         #x28018001f8
+  )
+
+
+(defmethod event-handler! juicer-shot ((obj juicer-shot) (arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  "Multiplex the projectile's event processing, called by [[projectile-event-handler]]"
+  (with-pp
+    (case arg2
+      (('reset)
+       (let ((v1-1 (the-as object (-> arg3 param 0))))
+         (set! (-> obj root-override trans quad) (-> (the-as matrix v1-1) trans quad))
+         (set! (-> obj starting-pos quad) (-> (the-as matrix v1-1) trans quad))
+         (set! (-> obj root-override transv quad) (-> (&+ (the-as matrix v1-1) 64) quad 0))
+         (set! (-> obj pre-move-transv quad) (-> (&+ (the-as matrix v1-1) 64) quad 0))
+         )
+       (set! (-> obj hits) 0)
+       (set! (-> obj spawn-time) (-> pp clock frame-counter))
+       (if (made-impact? obj)
+           (go (method-of-object obj impact))
+           (go (method-of-object obj moving))
+           )
+       #t
+       )
+      (else
+        ((method-of-type projectile event-handler!) obj arg0 arg1 arg2 arg3)
+        )
+      )
+    )
+  )
+
+(defstate dissipate (juicer-shot)
+  :virtual #t
+  :enter (behavior ()
+    (go-virtual impact)
+    (none)
+    )
+  )
+
+(defmethod deal-damage! juicer-shot ((obj juicer-shot) (arg0 process) (arg1 event-message-block))
+  "Constructs an [[attack-info]] according to the projectile's `options`"
+  (let ((a0-2 (if (type? arg0 process-focusable)
+                  arg0
+                  )
+              )
+        )
+    (when a0-2
+      (set! (-> obj victim) (process->handle a0-2))
+      #t
+      )
+    )
+  )
+
+(defmethod spawn-impact-particles juicer-shot ((obj juicer-shot))
+  "Spawns associated particles with the projectile if applicable"
+  (let ((s5-0 (-> obj starting-pos))
+        (s4-0 (-> obj root-override trans))
+        )
+    (when (line-in-view-frustum? s5-0 s4-0)
+      (let ((s3-0 (new 'stack-no-clear 'vector))
+            (s2-0 (new 'stack-no-clear 'vector))
+            (s1-0 (new 'stack-no-clear 'matrix))
+            )
+        (let ((t9-1 sp-launch-particles-var)
+              (a0-2 *sp-particle-system-2d*)
+              (a1-1 (-> *part-id-table* 4637))
+              (a2-0 *launch-matrix*)
+              )
+          (set! (-> a2-0 trans quad) (-> s5-0 quad))
+          (t9-1 a0-2 a1-1 a2-0 (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-2 (-> *part-id-table* 4638))
+              (a2-1 *launch-matrix*)
+              )
+          (set! (-> a2-1 trans quad) (-> s5-0 quad))
+          (t9-2 a0-3 a1-2 a2-1 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0)
+          )
+        (when (not (handle->process (-> obj victim)))
+          (let ((t9-3 sp-launch-particles-var)
+                (a0-8 *sp-particle-system-2d*)
+                (a1-4 (-> *part-id-table* 4637))
+                (a2-2 *launch-matrix*)
+                )
+            (set! (-> a2-2 trans quad) (-> s4-0 quad))
+            (t9-3 a0-8 a1-4 a2-2 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0)
+            )
+          (let ((t9-4 sp-launch-particles-var)
+                (a0-9 *sp-particle-system-2d*)
+                (a1-5 (-> *part-id-table* 4638))
+                (a2-3 *launch-matrix*)
+                )
+            (set! (-> a2-3 trans quad) (-> s4-0 quad))
+            (t9-4 a0-9 a1-5 a2-3 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0)
+            )
+          )
+        (vector-! s2-0 s4-0 s5-0)
+        (vector-normalize! s2-0 1.0)
+        (matrix-axis-angle! s1-0 s2-0 13107.2)
+        (vector-reset! (-> s1-0 trans))
+        (set-vector! s3-0 (-> s2-0 z) 0.0 (- (-> s2-0 x)) 1.0)
+        (vector-normalize! s3-0 409.6)
+        (dotimes (s0-0 5)
+          (vector-matrix*! s3-0 s3-0 s1-0)
+          (vector+! s2-0 s3-0 s5-0)
+          (let ((a0-17 (-> obj lightning s0-0))
+                (v1-21 s2-0)
+                )
+            (set! (-> a0-17 state meet data 0 quad) (-> v1-21 quad))
+            )
+          (let ((a0-20 (-> obj lightning s0-0))
+                (v1-25 s4-0)
+                )
+            (set! (-> a0-20 state meet data (+ (the-as int (-> a0-20 state points-to-draw)) -1) quad) (-> v1-25 quad))
+            )
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+(defmethod spawn-shell-particles juicer-shot ((obj juicer-shot))
+  "TODO - confirm"
+  (spawn-impact-particles obj)
+  (let ((s5-0 (get-process *default-dead-pool* part-tracker #x4000)))
+    (when s5-0
+      (let ((t9-2 (method-of-type part-tracker activate)))
+        (t9-2
+          (the-as part-tracker s5-0)
+          *entity-pool*
+          (symbol->string (-> part-tracker symbol))
+          (the-as pointer #x70004000)
+          )
+        )
+      (let ((t9-3 run-function-in-process)
+            (a0-4 s5-0)
+            (a1-2 part-tracker-init)
+            (a2-4 (-> *part-group-id-table* 1061))
+            (a3-1 0)
+            (t0-0 #f)
+            (t1-0 #f)
+            (t2-0 #f)
+            (t3-0 *launch-matrix*)
+            )
+        (set! (-> t3-0 trans quad) (-> obj root-override trans quad))
+        ((the-as (function object object object object object object object object none) t9-3)
+         a0-4
+         a1-2
+         a2-4
+         a3-1
+         t0-0
+         t1-0
+         t2-0
+         t3-0
+         )
+        )
+      (-> s5-0 ppointer)
+      )
+    )
+  0
+  (none)
+  )
+
+(defmethod made-impact? juicer-shot ((obj juicer-shot))
+  "TODO - queries the collision cache, return true/false"
+  (let ((gp-0 (-> obj root-override))
+        (s5-0 (new 'stack-no-clear 'collide-query))
+        )
+    (let ((v1-0 s5-0))
+      (set! (-> v1-0 radius) (-> gp-0 root-prim prim-core world-sphere w))
+      (set! (-> v1-0 collide-with) (-> gp-0 root-prim prim-core collide-with))
+      (set! (-> v1-0 ignore-process0) obj)
+      (set! (-> v1-0 ignore-process1) (ppointer->process (-> obj parent)))
+      (set! (-> v1-0 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+      (set! (-> v1-0 action-mask) (collide-action solid))
+      )
+    (let ((a0-2 (handle->process (-> obj notify-handle))))
+      (when a0-2
+        (let* ((s4-1 (vector-! (new 'stack-no-clear 'vector) (-> gp-0 trans) (get-trans (the-as process-focusable a0-2) 3)))
+               (f0-2 (- (vector-length s4-1)))
+               )
+          (fill-and-try-snap-to-surface gp-0 s4-1 f0-2 0.0 -3072.0 s5-0)
+          )
+        )
+      )
+    )
+  )
+
+(defbehavior juicer-proj-move juicer ((arg0 juicer-shot))
+  (let ((s5-0 (handle->process (-> arg0 victim))))
+    (cond
+      (s5-0
+        (set! (-> arg0 root-override trans quad) (-> (get-trans (the-as process-focusable s5-0) 3) quad))
+        ((method-of-type projectile deal-damage!) arg0 s5-0 (the-as event-message-block #f))
+        )
+      (else
+        (projectile-move-fill-line-sphere arg0)
+        (if (logtest? (-> arg0 root-override status) (collide-status touch-surface))
+            (go (method-of-object arg0 impact))
+            )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+(defmethod init-collision! juicer-shot ((obj juicer-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) cshape-reaction-default)
+    (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 ((v1-7 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-7 prim-core collide-as) (collide-spec projectile))
+      (set! (-> v1-7 prim-core collide-with)
+            (collide-spec
+              backgnd
+              jak
+              bot
+              crate
+              civilian
+              enemy
+              obstacle
+              vehicle-sphere
+              hit-by-others-list
+              player-list
+              pusher
+              )
+            )
+      (set! (-> v1-7 prim-core action) (collide-action solid))
+      (set-vector! (-> v1-7 local-sphere) 0.0 0.0 0.0 1228.8)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) v1-7)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-10 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-10 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-10 prim-core collide-with))
+      )
+    (set! (-> s5-0 max-iteration-count) (the-as uint 1))
+    (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)
+        )
+  (none)
+  )
+
+;; WARN: Return type mismatch projectile vs juicer-shot.
+(defmethod relocate juicer-shot ((obj juicer-shot) (arg0 int))
+  (dotimes (v1-0 5)
+    (if (nonzero? (-> obj lightning v1-0))
+        (&+! (-> obj lightning v1-0) arg0)
+        )
+    )
+  (the-as juicer-shot ((method-of-type projectile relocate) obj arg0))
+  )
+
+(defmethod init-proj-settings! juicer-shot ((obj juicer-shot))
+  "Init relevant settings for the [[projectile]] such as gravity, speed, timeout, etc
+:virtual"
+  (logior! (-> obj options) (projectile-options proj-options-8000))
+  (set! (-> obj attack-mode) 'eco-yellow)
+  (set! (-> obj move) juicer-proj-move)
+  (set! (-> obj root-override dynam gravity y) 0.0)
+  (set! (-> obj root-override dynam gravity-length) 0.0)
+  (set! (-> obj root-override dynam gravity-max) 0.0)
+  (set! (-> obj attack-mode) 'shock-red)
+  (dotimes (s5-0 5)
+    (set! (-> obj lightning s5-0) (new
+                                    'process
+                                    'lightning-control
+                                    (new 'static 'lightning-spec
+                                      :name #f
+                                      :flags (lightning-spec-flags lsf0)
+                                      :start-color (new 'static 'rgba :r #x80 :g #x80 :b #x80 :a #x80)
+                                      :end-color (new 'static 'rgba :r #x80 :g #x80 :b #x80 :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 #x86 :page #xc)
+                                      :reduction 0.42
+                                      :num-points 8
+                                      :box-size 8192.0
+                                      :merge-factor 0.5
+                                      :merge-count 2
+                                      :radius 1433.6
+                                      :duration -1.0
+                                      :sound #f
+                                      )
+                                    obj
+                                    0.0
+                                    )
+          )
+    )
+  (set! (-> obj victim) (the-as handle #f))
+  0
+  (none)
+  )
+
+(defskelgroup skel-juicer juicer juicer-lod0-jg -1
+              ((juicer-lod0-mg (meters 20)) (juicer-lod1-mg (meters 40)) (juicer-lod2-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 5.3)
+              :shadow juicer-shadow-mg
+              :origin-joint-index 21
+              )
+
+(deftype juicer-anim-info (structure)
+  ((anim-index int32  :offset-assert   0)
+   )
+  :method-count-assert 9
+  :size-assert         #x4
+  :flag-assert         #x900000004
+  )
+
+
+(deftype juicer-global-info (basic)
+  ((prev-yellow-hit int8    :offset-assert   4)
+   (prev-blue-hit   int8    :offset-assert   5)
+   (idle-anim       int32 3 :offset-assert   8)
+   (patrol-anim     int32 2 :offset-assert  20)
+   (notice-anim     int32 2 :offset-assert  28)
+   (charge-anim     int32 2 :offset-assert  36)
+   (knocked-anim    int32 2 :offset-assert  44)
+   (celebrate-anim  int32 2 :offset-assert  52)
+   (yellow-hit-anim int32 4 :offset-assert  60)
+   (blue-hit-anim   int32 6 :offset-assert  76)
+   )
+  :method-count-assert 9
+  :size-assert         #x64
+  :flag-assert         #x900000064
+  )
+
+
+(deftype juicer (nav-enemy)
+  ((los                los-control  :inline :offset-assert 608)
+   (intro-path         path-control         :offset-assert 756)
+   (joint              joint-mod            :offset-assert 760)
+   (joint-enable       symbol               :offset-assert 764)
+   (joint-blend        float                :offset-assert 768)
+   (last-fire-time     time-frame           :offset-assert 776)
+   (heading            basic                :offset-assert 784)
+   (move-angle         float                :offset-assert 788)
+   (torso-track-player basic                :offset-assert 792)
+   (circle-backward?   symbol               :offset        800)
+   (using-turn-anim    symbol               :offset-assert 804)
+   (hit-focus          enemy-focus          :offset-assert 808)
+   (ambush-path-pt     int8                 :offset-assert 812)
+   (charge-index       int8                 :offset-assert 813)
+   (hostile-dest       vector       :inline :offset-assert 816)
+   (focus-is-up        symbol               :offset-assert 832)
+   (current-projectile handle               :offset-assert 840)
+   )
+  :heap-base #x2d0
+  :method-count-assert 185
+  :size-assert         #x350
+  :flag-assert         #xb902d00350
+  (:methods
+    (ambush-cont () _type_ :state 178)
+    (attack () _type_ :state 179)
+    (juicer-method-180 (_type_) none 180)
+    (fire-projectile (_type_ process-focusable uint) none 181)
+    (juicer-method-182 (_type_) none 182)
+    (juicer-method-183 (_type_) none 183)
+    (juicer-method-184 (_type_ symbol) none 184)
+    )
+  )
+
+
+(define *juicer-global-info* (new 'static 'juicer-global-info
+                               :idle-anim (new 'static 'array int32 3 5 6 7)
+                               :patrol-anim (new 'static 'array int32 2 8 23)
+                               :notice-anim (new 'static 'array int32 2 21 22)
+                               :charge-anim (new 'static 'array int32 2 9 20)
+                               :knocked-anim (new 'static 'array int32 2 16 18)
+                               :celebrate-anim (new 'static 'array int32 2 24 25)
+                               :yellow-hit-anim (new 'static 'array int32 4 33 34 35 36)
+                               :blue-hit-anim (new 'static 'array int32 6 26 27 28 29 30 31)
+                               )
+        )
+
+(define *juicer-nav-enemy-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #t
+    :use-victory #t
+    :use-jump-blocked #t
+    :debug-draw-neck #f
+    :jump-debug-draw #f
+    :move-to-ground #t
+    :hover-if-no-ground #f
+    :idle-anim-script (new 'static 'array idle-control-frame 4
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x5 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 5
+    :notice-anim 21
+    :hostile-anim 9
+    :hit-anim 11
+    :knocked-anim 18
+    :knocked-land-anim 19
+    :die-anim 40
+    :die-falling-anim 41
+    :victory-anim 24
+    :jump-wind-up-anim 37
+    :jump-in-air-anim 38
+    :jump-land-anim 39
+    :neck-joint 34
+    :look-at-joint 34
+    :bullseye-joint 6
+    :sound-hit (static-sound-name "juicer-hit")
+    :sound-die (static-sound-name "juicer-die")
+    :notice-distance (meters 30)
+    :notice-distance-delta (meters 10)
+    :proximity-notice-distance (meters 24)
+    :default-hit-points 9
+    :gnd-collide-with (collide-spec backgnd)
+    :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.9
+    :attack-shove-back (meters 3)
+    :attack-shove-up (meters 2)
+    :attack-mode 'shock-red
+    :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 65536.0
+    :knocked-soft-vxz-hi 94208.0
+    :knocked-soft-vy-lo 77824.0
+    :knocked-soft-vy-hi 98304.0
+    :knocked-medium-vxz-lo 81920.0
+    :knocked-medium-vxz-hi 98304.0
+    :knocked-medium-vy-lo 81920.0
+    :knocked-medium-vy-hi 122880.0
+    :knocked-hard-vxz-lo 65536.0
+    :knocked-hard-vxz-hi 95846.4
+    :knocked-hard-vy-lo 122880.0
+    :knocked-hard-vy-hi 163840.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 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 98304.0
+    :knocked-red-vy-lo 90112.0
+    :knocked-red-vy-hi 131072.0
+    :knocked-blue-vxz-lo 24576.0
+    :knocked-blue-vxz-hi 32768.0
+    :knocked-blue-vy-lo 24576.0
+    :knocked-blue-vy-hi 73728.0
+    :shadow-size (meters 2)
+    :shadow-max-y (meters 1)
+    :shadow-min-y (meters -1)
+    :shadow-locus-dist (meters 150)
+    :gem-joint 34
+    :gem-seg #x2
+    :gem-no-seg #x4
+    :gem-offset (new 'static 'sphere :y 942.08 :z 40.96 :r 163840.0)
+    :callback-info #f
+    :use-momentum #f
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #t
+    :use-pacing #t
+    :walk-anim 8
+    :turn-anim 10
+    :run-anim 9
+    :taunt-anim -1
+    :run-travel-speed (meters 8)
+    :run-acceleration (meters 8)
+    :run-turning-acceleration (meters 20)
+    :walk-travel-speed (meters 2)
+    :walk-acceleration (meters 2)
+    :walk-turning-acceleration (meters 3)
+    :maximum-rotation-rate (degrees 360.0)
+    :notice-nav-radius (meters 7.5)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 28672.0
+    :circle-dist-hi 53248.0
+    :nav-mesh #f
+    )
+  )
+
+(set! (-> *juicer-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+(defmethod juicer-method-182 juicer ((obj juicer))
+  (let ((s3-0 (handle->process (-> obj focus handle))))
+    (when s3-0
+      (let ((s4-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 4)))
+            (s5-0 (new 'stack-no-clear 'vector))
+            )
+        (set! (-> s5-0 quad) (-> (get-trans (the-as process-focusable s3-0) 3) quad))
+        (let ((s3-1
+                (vector-normalize-copy! (new 'stack-no-clear 'vector) (-> obj node-list data 4 bone transform vector 2) 1.0)
+                )
+              )
+          (vector-! s5-0 s5-0 s4-0)
+          (vector-normalize! s5-0 1.0)
+          (quaternion-from-two-vectors-partial! (-> obj joint quat) s3-1 s5-0 (-> obj joint-blend))
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+(defmethod juicer-method-183 juicer ((obj juicer))
+  (with-pp
+    (cond
+      ((-> obj torso-track-player)
+       (set! (-> obj joint-enable) #t)
+       (seek! (-> obj joint-blend) 1.0 (* 2.0 (-> pp clock seconds-per-frame)))
+       (juicer-method-182 obj)
+       )
+      ((-> obj joint-enable)
+       (seek! (-> obj joint-blend) 0.0 (* 4.0 (-> pp clock seconds-per-frame)))
+       (juicer-method-182 obj)
+       (if (= (-> obj joint-blend) 0.0)
+           (set! (-> obj joint-enable) #f)
+           )
+       )
+      )
+    0
+    (none)
+    )
+  )
+
+(defmethod enemy-method-55 juicer ((obj juicer))
+  (let ((t9-0 (method-of-type nav-enemy enemy-method-55)))
+    (t9-0 obj)
+    )
+  (los-control-method-9 (-> obj los) (the-as process-focusable #f) (the-as vector #f) 2048.0)
+  (juicer-method-183 obj)
+  (none)
+  )
+
+(defmethod juicer-method-180 juicer ((obj juicer))
+  (if (and (= (-> obj incoming knocked-type) (knocked-type knocked-type-4))
+           (not (and (-> obj next-state) (let ((v1-6 (-> obj next-state name)))
+                                           (or (= v1-6 'knocked) (= v1-6 'jump) (= v1-6 'jump-land))
+                                           )
+                     )
+                )
+           (zero? (get-rand-int obj 3))
+           (let ((f0-0 (vector-vector-distance-squared (-> obj root-override2 trans) (target-pos 0)))
+                 (f1-0 32768.0)
+                 )
+             (>= f0-0 (* f1-0 f1-0))
+             )
+           )
+      (enemy-method-73 obj)
+      (go (method-of-object obj knocked))
+      )
+  (none)
+  )
+
+(defmethod enemy-method-74 juicer ((obj juicer) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (case arg2
+    (('hit-flinch)
+     (cond
+       ((zero? (-> obj hit-points))
+        (logclear! (-> obj mask) (process-mask actor-pause))
+        (logclear! (-> obj focus-status) (focus-status dangerous))
+        (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice))
+        (logior! (-> obj enemy-flags) (enemy-flag chase-startup))
+        (logior! (-> obj focus-status) (focus-status hit))
+        (if (zero? (-> obj hit-points))
+            (logior! (-> obj focus-status) (focus-status dead))
+            )
+        (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup))
+        (enemy-method-62 obj)
+        (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
+        (process-contact-action arg0)
+        (send-event arg0 'get-attack-count 1)
+        (juicer-method-180 obj)
+        )
+       (else
+         (let ((v1-31 (ja-channel-float! (the-as art-joint-anim (-> obj draw art-group data 11)) 0.0 0.0 0.0)))
+           (when v1-31
+             (set! (-> v1-31 param 0) 1.0)
+             (set! (-> v1-31 param 1) 0.75)
+             (set! (-> v1-31 param 2) 2.0)
+             (set! (-> v1-31 num-func) num-func-interp-play!)
+             )
+           )
+         )
+       )
+     #t
+     )
+    (('hit)
+     (logclear! (-> obj mask) (process-mask actor-pause))
+     (logclear! (-> obj focus-status) (focus-status dangerous))
+     (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice))
+     (logior! (-> obj enemy-flags) (enemy-flag chase-startup))
+     (logior! (-> obj focus-status) (focus-status hit))
+     (if (zero? (-> obj hit-points))
+         (logior! (-> obj focus-status) (focus-status dead))
+         )
+     (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup))
+     (enemy-method-62 obj)
+     (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
+     (process-contact-action arg0)
+     (send-event arg0 'get-attack-count 1)
+     (if (zero? (-> obj hit-points))
+         (juicer-method-180 obj)
+         (go (method-of-object obj hit))
+         )
+     #t
+     )
+    (('instant-death)
+     (when (> (-> obj hit-points) 0)
+       (set! (-> obj hit-points) 0)
+       (set! (-> obj root-override2 penetrated-by) (enemy-method-59 obj))
+       (let ((s4-0 (enemy-method-50 obj (new 'stack-no-clear 'vector))))
+         (vector-z-quaternion! s4-0 (-> obj root-override2 quat))
+         (vector-float*! s4-0 s4-0 -1.0)
+         (vector-normalize! s4-0 1.0)
+         )
+       (logclear! (-> obj mask) (process-mask actor-pause))
+       (logclear! (-> obj focus-status) (focus-status dangerous))
+       (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice))
+       (logior! (-> obj enemy-flags) (enemy-flag chase-startup))
+       (logior! (-> obj focus-status) (focus-status hit))
+       (if (zero? (-> obj hit-points))
+           (logior! (-> obj focus-status) (focus-status dead))
+           )
+       (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup))
+       (enemy-method-62 obj)
+       (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
+       (process-contact-action arg0)
+       (send-event arg0 'get-attack-count 1)
+       (juicer-method-180 obj)
+       )
+     #t
+     )
+    (('notify)
+     (if (and (= (-> arg3 param 0) 'attack) (= (-> arg3 param 1) (handle->process (-> obj focus handle))))
+         (set! (-> obj hit-focus) (the-as enemy-focus #t))
+         )
+     ((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)
+      )
+    )
+  )
+
+(defstate active (juicer)
+  :virtual #t
+  :code (behavior ()
+    (let ((v1-2 (ja-group)))
+      (when (or (and v1-2 (or (= v1-2 juicer-charge0-ja) (= v1-2 juicer-charge1-ja)))
+                (let ((v1-8 (ja-group)))
+                  (and v1-8 (or (= v1-8 juicer-patrol0-ja) (= v1-8 juicer-patrol1-ja)))
+                  )
+                )
+        (ja-no-eval :num! (seek!))
+        (while (not (ja-done? 0))
+          (suspend)
+          (ja-eval)
+          )
+        )
+      )
+    (let ((f30-0 (get-rand-float-range self 0.9 1.1)))
+      (until #f
+        (let ((gp-0 (-> self draw art-group data (-> (&-> *juicer-global-info* patrol-anim (get-rand-int self 2)) 0)))
+              (s5-0 (get-rand-int-range self 1 8))
+              )
+          (let ((v1-34 (ja-group)))
+            (if (not (and v1-34 (= v1-34 gp-0)))
+                (ja-channel-push! 1 (seconds 0.2))
+                )
+            )
+          (dotimes (s4-0 s5-0)
+            (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))
+              )
+            )
+          )
+        (when (zero? (get-rand-int self 2))
+          (let ((v1-58 self))
+            (set! (-> v1-58 enemy-flags) (the-as enemy-flag (logclear (-> v1-58 enemy-flags) (enemy-flag enemy-flag36))))
+            (set! (-> v1-58 nav callback-info) *nav-enemy-null-callback-info*)
+            )
+          0
+          (ja-channel-push! 1 (seconds 0.3))
+          (let ((gp-1 0))
+            (until (not (enemy-method-123 self 0.4))
+              (let* ((v1-62 (enemy-method-120 self 3 gp-1))
+                     (a1-16 (-> self draw art-group data (-> *juicer-global-info* idle-anim v1-62)))
+                     )
+                (set! gp-1 (ash 1 v1-62))
+                (ja-no-eval :group! a1-16
+                            :num! (seek! (the float (+ (-> (the-as art-joint-anim a1-16) frames num-frames) -1)) f30-0)
+                            :frame-num 0.0
+                            )
+                )
+              (ja-no-eval :group! (ja-group)
+                          :num! (seek! (the float (+ (-> (ja-group) frames num-frames) -1)) f30-0)
+                          :frame-num 0.0
+                          )
+              (until (ja-done? 0)
+                (suspend)
+                (ja :num! (seek! max f30-0))
+                )
+              )
+            )
+          (let ((v1-102 self))
+            (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-102 enemy-flags)))
+                (set! (-> v1-102 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-102 enemy-flags))))
+                )
+            (set! (-> v1-102 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-102 enemy-flags))))
+            (set! (-> v1-102 nav callback-info) (-> v1-102 enemy-info-override callback-info))
+            )
+          0
+          )
+        )
+      )
+    #f
+    (none)
+    )
+  )
+
+(defmethod enemy-method-84 juicer ((obj juicer) (arg0 enemy-jump-info))
+  (cond
+    ((logtest? (-> obj fact-info-override enemy-options) (enemy-option user8))
+     (vector-vector-xz-distance (-> arg0 start-pos) (-> arg0 dest-pos))
+     (let ((f0-1 8192.0))
+       (setup-from-to-height! (-> arg0 traj) (-> arg0 start-pos) (-> arg0 dest-pos) f0-1 -4.551111)
+       )
+     )
+    (else
+      ((method-of-type nav-enemy enemy-method-84) obj arg0)
+      )
+    )
+  (none)
+  )
+
+(defmethod enemy-method-93 juicer ((obj juicer))
+  (case (-> obj jump-why)
+    ((2)
+     (go (method-of-object obj ambush-cont))
+     )
+    (else
+      ((method-of-type nav-enemy enemy-method-93) obj)
+      )
+    )
+  (none)
+  )
+
+(defstate ambush (juicer)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy ambush) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (when (zero? (-> self intro-path))
+      (format 0 "ERROR: ~A has no intro path, skipping ambush~%" (-> self name))
+      (go-virtual notice)
+      )
+    (get-point-in-path! (-> self intro-path) (-> self root-override2 trans) 0.0 'interp)
+    (none)
+    )
+  :code (behavior ()
+    (set! (-> self ambush-path-pt) 1)
+    (until #f
+      (let ((gp-0 (new 'stack-no-clear 'vector)))
+        (get-point-in-path! (-> self intro-path) gp-0 1.0 'interp)
+        (set! (-> self enemy-flags) (the-as enemy-flag (logclear (-> self enemy-flags) (enemy-flag vulnerable))))
+        (let ((a1-1 (new 'stack-no-clear 'event-message-block)))
+          (let ((v1-5 (process->ppointer self)))
+            (set! (-> a1-1 from) v1-5)
+            )
+          (set! (-> a1-1 num-params) 2)
+          (set! (-> a1-1 message) 'jump)
+          (set! (-> a1-1 param 0) (the-as uint 2))
+          (set! (-> a1-1 param 1) (the-as uint gp-0))
+          (send-event-function self a1-1)
+          )
+        )
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  )
+
+(defstate ambush-cont (juicer)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior juicer) enemy-event-handler)
+  :code (behavior ()
+    (let ((a0-0 (-> self intro-path))
+          (v1-1 (+ (-> self ambush-path-pt) 1))
+          )
+      (if (< v1-1 (-> a0-0 curve num-cverts))
+          (set! (-> self ambush-path-pt) v1-1)
+          (enemy-method-72 self)
+          )
+      )
+    (until #f
+      (let ((gp-0 (new 'stack-no-clear 'vector)))
+        (get-point-in-path! (-> self intro-path) gp-0 (the float (-> self ambush-path-pt)) 'interp)
+        (set! (-> self enemy-flags) (the-as enemy-flag (logclear (-> self enemy-flags) (enemy-flag vulnerable))))
+        (let ((a1-1 (new 'stack-no-clear 'event-message-block)))
+          (let ((v1-9 (process->ppointer self)))
+            (set! (-> a1-1 from) v1-9)
+            )
+          (set! (-> a1-1 num-params) 2)
+          (set! (-> a1-1 message) 'jump)
+          (set! (-> a1-1 param 0) (the-as uint 2))
+          (set! (-> a1-1 param 1) (the-as uint gp-0))
+          (send-event-function self a1-1)
+          )
+        )
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  )
+
+(defstate notice (juicer)
+  :virtual #t
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.075))
+    (let ((s5-0 0))
+      (let ((s4-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override2 quat)))
+            (gp-1 (vector-!
+                    (new 'stack-no-clear 'vector)
+                    (get-trans (the-as process-focusable (handle->process (-> self focus handle))) 0)
+                    (-> self root-override2 trans)
+                    )
+                  )
+            )
+        (vector-flatten! gp-1 gp-1 (-> s4-0 vector 1))
+        (vector-normalize! gp-1 1.0)
+        (cond
+          ((< (vector-dot gp-1 (-> s4-0 vector 2)) (cos 8192.0))
+           )
+          (else
+            (set! s5-0 (logior s5-0 1))
+            )
+          )
+        )
+      (let ((f30-1 (get-rand-float-range self 0.8 1.2))
+            (gp-2 (new 'stack-no-clear 'vector))
+            )
+        (let* ((a0-13 (enemy-method-120 self 2 s5-0))
+               (a1-8 (-> self draw art-group data (-> *juicer-global-info* notice-anim a0-13)))
+               )
+          (ja-no-eval :group! a1-8
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim a1-8) frames num-frames) -1)) f30-1)
+                      :frame-num 0.0
+                      )
+          )
+        (until (ja-done? 0)
+          (let ((a1-9 (-> self nav state)))
+            (set! (-> gp-2 quad) (-> a1-9 travel quad))
+            )
+          (seek-toward-heading-vec! (-> self root-override2) gp-2 (-> self nav max-rotation-rate) (seconds 0.02))
+          (suspend)
+          (ja :num! (seek! max f30-1))
+          )
+        )
+      )
+    (enemy-method-72 self)
+    (none)
+    )
+  )
+
+(defstate victory (juicer)
+  :virtual #t
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.15))
+    (let ((gp-1 (-> self draw art-group data (-> *juicer-global-info* celebrate-anim (get-rand-int self 2))))
+          (f30-0 (get-rand-float-range self 0.9 1.1))
+          )
+      (ja-no-eval :group! gp-1
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-1) frames num-frames) -1)) f30-0)
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      )
+    (enemy-method-72 self)
+    (none)
+    )
+  )
+
+(defstate hostile (juicer)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy hostile) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self focus-is-up) #f)
+    (none)
+    )
+  :exit (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy hostile) exit)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((v1-2 (ja-group)))
+      (when (and v1-2 (or (= v1-2 juicer-charge0-ja) (= v1-2 juicer-charge1-ja)))
+        (ja-no-eval :num! (seek!))
+        (while (not (ja-done? 0))
+          (suspend)
+          (ja-eval)
+          )
+        )
+      )
+    (let* ((v1-16 (get-rand-int self 2))
+           (gp-0 (-> self draw art-group data (-> *juicer-global-info* charge-anim v1-16)))
+           )
+      (set! (-> self charge-index) v1-16)
+      (let ((v1-19 (ja-group)))
+        (if (not (and v1-19 (= v1-19 gp-0)))
+            (ja-channel-push! 1 (seconds 0.2))
+            )
+        )
+      (set! (-> self skel root-channel 0 frame-group) (the-as art-joint-anim gp-0))
+      )
+    (ja :num-func num-func-identity :frame-num 0.0)
+    (let ((f30-0 (get-rand-float-range self 0.9 1.1)))
+      (until #f
+        (suspend)
+        (ja :num! (loop! f30-0))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (let ((a0-1 (handle->process (-> self focus handle))))
+      (when a0-1
+        (let* ((gp-0 (get-trans (the-as process-focusable a0-1) 1))
+               (f30-0 (vector-vector-xz-distance (-> self root-override2 trans) gp-0))
+               )
+          (cond
+            ((< (- (-> gp-0 y) (-> self root-override2 trans y)) 4096.0)
+             (let ((v1-10 (-> self nav state)))
+               (logclear! (-> v1-10 flags) (nav-state-flag directional-mode))
+               (logior! (-> v1-10 flags) (nav-state-flag target-poly-dirty))
+               (set! (-> v1-10 target-post quad) (-> gp-0 quad))
+               )
+             0
+             (set! (-> self focus-is-up) #f)
+             )
+            ((not (-> self focus-is-up))
+             (let ((s4-0 (new 'stack-no-clear 'vector))
+                   (s5-0 (new 'stack-no-clear 'vector))
+                   )
+               (let ((f28-0 (rand-vu-float-range 0.0 65536.0)))
+                 (set-vector! s4-0 (* 8192.0 (cos f28-0)) 0.0 (* 8192.0 (sin f28-0)) 1.0)
+                 )
+               (vector+! s4-0 s4-0 gp-0)
+               (cloest-point-on-mesh (-> self nav) s4-0 s4-0 (the-as nav-poly #f))
+               (vector-! s5-0 s4-0 gp-0)
+               (set! (-> s5-0 y) 0.0)
+               (vector-normalize! s5-0 30720.0)
+               (vector+! s5-0 s5-0 s4-0)
+               (let ((v1-24 (-> self nav state)))
+                 (logclear! (-> v1-24 flags) (nav-state-flag directional-mode))
+                 (logior! (-> v1-24 flags) (nav-state-flag target-poly-dirty))
+                 (set! (-> v1-24 target-post quad) (-> s5-0 quad))
+                 )
+               )
+             0
+             (set! (-> self focus-is-up) #t)
+             )
+            (else
+              (when (and (or (logtest? (-> self nav state flags) (nav-state-flag blocked))
+                             (logtest? (-> self nav state flags) (nav-state-flag at-target))
+                             )
+                         (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+                         )
+                (if (and (>= (- (-> self clock frame-counter) (-> self last-fire-time)) (rand-vu-int-range (seconds 1) (seconds 2)))
+                         (< 20480.0 f30-0)
+                         )
+                    (go-virtual attack)
+                    (go-virtual circling)
+                    )
+                )
+              )
+            )
+          (if (and (check-los? (-> self los) 0)
+                   (or (>= 11468.8 f30-0)
+                       (and (>= (- (-> self clock frame-counter) (-> self last-fire-time)) (rand-vu-int-range (seconds 5) (seconds 8)))
+                            (>= 53248.0 f30-0)
+                            )
+                       )
+                   )
+              (go-virtual attack)
+              )
+          )
+        )
+      )
+    (nav-enemy-travel-post)
+    (none)
+    )
+  )
+
+(defbehavior juicer-face-player-post juicer ()
+  (let ((gp-0 (handle->process (-> self focus handle)))
+        (a0-3 self)
+        )
+    (when (and (logtest? (enemy-flag enemy-flag37) (-> a0-3 enemy-flags)) gp-0)
+      (let ((f0-1 (fabs (deg-diff
+                          (quaternion-y-angle (-> self root-override2 quat))
+                          (vector-y-angle (vector-!
+                                            (new 'stack-no-clear 'vector)
+                                            (get-trans (the-as process-focusable gp-0) 0)
+                                            (-> self root-override2 trans)
+                                            )
+                                          )
+                          )
+                        )
+                  )
+            )
+        (cond
+          ((or (< 5461.3335 f0-1) (and (-> self using-turn-anim) (< 910.2222 f0-1)))
+           (set! (-> self using-turn-anim) #t)
+           (seek-to-point-toward-point!
+             (-> self root-override2)
+             (get-trans (the-as process-focusable gp-0) 0)
+             (-> self nav max-rotation-rate)
+             (seconds 0.2)
+             )
+           )
+          (else
+            (set! (-> self using-turn-anim) #f)
+            )
+          )
+        )
+      )
+    )
+  (nav-enemy-simple-post)
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod fire-projectile juicer ((obj juicer) (arg0 process-focusable) (arg1 uint))
+  (with-pp
+    (let ((s4-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 20)))
+          (s5-0 (new 'stack-no-clear 'projectile-init-by-other-params))
+          )
+      (when (not (handle->process (-> obj current-projectile)))
+        (set! (-> s5-0 ent) (-> obj entity))
+        (set! (-> s5-0 charge) 1.0)
+        (set! (-> s5-0 options) (projectile-options))
+        (set! (-> s5-0 notify-handle) (process->handle obj))
+        (set! (-> s5-0 owner-handle) (the-as handle #f))
+        (set! (-> s5-0 ignore-handle) (process->handle obj))
+        (set! (-> s5-0 attack-id) arg1)
+        (set! (-> s5-0 timeout) (new 'static 'handle :process #x4b0 :u64 #x4b0))
+        )
+      (vector-normalize! (vector-! (-> s5-0 pos) (get-trans arg0 3) s4-0) 1.0)
+      (vector-float*! (-> s5-0 vel) (-> s5-0 pos) (* 24576.0 (-> pp clock frames-per-second)))
+      (vector+float*! (-> s5-0 pos) s4-0 (-> s5-0 pos) -1024.0)
+      (let ((a0-20 (handle->process (-> obj current-projectile))))
+        (if a0-20
+            (send-event a0-20 'reset s5-0)
+            (set! (-> obj current-projectile)
+                  (ppointer->handle (spawn-projectile juicer-shot s5-0 obj *default-dead-pool*))
+                  )
+            )
+        )
+      )
+    (none)
+    )
+  )
+
+(defstate attack (juicer)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior juicer) enemy-event-handler)
+  :enter (behavior ()
+    (let ((v1-1 (-> self nav state))
+          (a0-1 (-> self root-override2 trans))
+          )
+      (logclear! (-> v1-1 flags) (nav-state-flag directional-mode))
+      (logior! (-> v1-1 flags) (nav-state-flag target-poly-dirty))
+      (set! (-> v1-1 target-post quad) (-> a0-1 quad))
+      )
+    0
+    (set! (-> self torso-track-player) (the-as basic #t))
+    (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags)))
+    (set! (-> self hit-focus) #f)
+    (logior! (-> self focus-status) (focus-status dangerous))
+    (let* ((v1-9 *game-info*)
+           (v0-0 (+ (-> v1-9 attack-id) 1))
+           )
+      (set! (-> v1-9 attack-id) v0-0)
+      (set! (-> self attack-id) v0-0)
+      )
+    (none)
+    )
+  :exit (behavior ()
+    (set! (-> self torso-track-player) #f)
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (juicer-method-184 self #f)
+    (set! (-> self last-fire-time) (-> self clock frame-counter))
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (send-event (handle->process (-> self current-projectile)) 'die)
+    (none)
+    )
+  :trans (behavior ()
+    (when (skip-check-los? (-> self los) 90)
+      )
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.1))
+    (ja-no-eval :group! juicer-attack0-start-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim juicer-attack0-start-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (if (< 11.0 (ja-aframe-num 0))
+          (juicer-method-184 self #t)
+          )
+      (suspend)
+      (ja :num! (seek!))
+      )
+    0
+    (let* ((gp-0 #f)
+           (v1-29 *game-info*)
+           (s5-0 (+ (-> v1-29 attack-id) 1))
+           )
+      (set! (-> v1-29 attack-id) s5-0)
+      (let ((s4-0 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) s4-0) (seconds 0.25))
+          (ja-no-eval :group! juicer-attack0-ja
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim juicer-attack0-ja) frames num-frames) -1)))
+                      :frame-num 0.0
+                      )
+          (until (ja-done? 0)
+            (let ((s3-0 (handle->process (-> self focus handle))))
+              (when s3-0
+                (when (< 28672.0
+                         (vector-vector-distance (-> self root-override2 trans) (get-trans (the-as process-focusable s3-0) 0))
+                         )
+                  (fire-projectile self (the-as process-focusable s3-0) s5-0)
+                  (-> self clock frame-counter)
+                  (if (not gp-0)
+                      (set! gp-0 #t)
+                      )
+                  )
+                )
+              )
+            (if (and (logtest? (-> self enemy-flags) (enemy-flag look-at-focus)) (-> self enemy-info-override use-victory))
+                (go-virtual victory)
+                )
+            (b!
+              (not (and (-> self using-turn-anim) (let ((v1-73 (ja-group)))
+                                                    (not (and v1-73 (= v1-73 juicer-attack-turn-ja)))
+                                                    )
+                        )
+                   )
+              cfg-31
+              :delay (empty-form)
+              )
+            (ja-channel-push! 1 (seconds 0.05))
+            (ja :group! juicer-attack-turn-ja)
+            (b! #t cfg-42 :delay (nop!))
+            (label cfg-31)
+            (when (and (not (-> self using-turn-anim)) (let ((v1-84 (ja-group)))
+                                                         (not (and v1-84 (= v1-84 juicer-attack0-ja)))
+                                                         )
+                       )
+              (ja-channel-push! 1 (seconds 0.05))
+              (ja :group! juicer-attack0-ja)
+              )
+            (label cfg-42)
+            (suspend)
+            (ja :num! (seek!))
+            )
+          (send-event (handle->process (-> self current-projectile)) 'die)
+          (let ((a0-37 (handle->process (-> self focus handle))))
+            (when a0-37
+              (if (>= 28672.0
+                      (vector-vector-distance (-> self root-override2 trans) (get-trans (the-as process-focusable a0-37) 0))
+                      )
+                  (go-virtual circling)
+                  )
+              )
+            )
+          (suspend)
+          )
+        )
+      )
+    (if (-> self hit-focus)
+        (go-virtual victory)
+        )
+    (go-hostile self)
+    (none)
+    )
+  :post juicer-face-player-post
+  )
+
+(defstate circling (juicer)
+  :virtual #t
+  :code (behavior ()
+    (let ((v1-2 (ja-group)))
+      (when (and v1-2 (or (= v1-2 juicer-charge0-ja) (= v1-2 juicer-charge1-ja)))
+        (ja-no-eval :num! (seek!))
+        (while (not (ja-done? 0))
+          (suspend)
+          (ja-eval)
+          )
+        )
+      )
+    (until #f
+      (let ((v1-15 self))
+        (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-15 enemy-flags)))
+            (set! (-> v1-15 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-15 enemy-flags))))
+            )
+        (set! (-> v1-15 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-15 enemy-flags))))
+        (set! (-> v1-15 nav callback-info) (-> v1-15 enemy-info-override callback-info))
+        )
+      0
+      (let ((v1-18 self))
+        (set! (-> v1-18 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-18 enemy-flags))))
+        )
+      0
+      (nav-enemy-method-166 self)
+      (let* ((v1-23 (get-rand-int self 2))
+             (gp-0 (-> self draw art-group data (-> *juicer-global-info* charge-anim v1-23)))
+             )
+        (set! (-> self charge-index) v1-23)
+        (let ((v1-26 (ja-group)))
+          (if (not (and v1-26 (= v1-26 gp-0)))
+              (ja-channel-push! 1 (seconds 0.15))
+              )
+          )
+        (let ((s5-0 (+ (get-rand-int self 6) 2))
+              (f30-0 (get-rand-float-range self 0.9 1.1))
+              )
+          (while (nonzero? s5-0)
+            (+! s5-0 -1)
+            (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))
+              )
+            )
+          )
+        )
+      (when (< 20480.0 (vector-vector-xz-distance (-> self focus-pos) (-> self root-override2 trans)))
+        (let ((v1-54 self))
+          (set! (-> v1-54 enemy-flags) (the-as enemy-flag (logclear (-> v1-54 enemy-flags) (enemy-flag enemy-flag36))))
+          (set! (-> v1-54 nav callback-info) *nav-enemy-null-callback-info*)
+          )
+        0
+        (let ((v1-57 self))
+          (set! (-> v1-57 enemy-flags) (the-as enemy-flag (logclear (-> v1-57 enemy-flags) (enemy-flag enemy-flag37))))
+          )
+        0
+        (vector-reset! (-> self root-override2 transv))
+        (ja-channel-push! 1 (seconds 0.1))
+        (let ((gp-2 (-> self draw art-group data (-> *juicer-global-info* celebrate-anim (get-rand-int self 2))))
+              (f30-2 (get-rand-float-range self 0.9 1.1))
+              )
+          (ja-no-eval :group! gp-2
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-2) frames num-frames) -1)) f30-2)
+                      :frame-num 0.0
+                      )
+          (until (ja-done? 0)
+            (suspend)
+            (ja :num! (seek! max f30-2))
+            )
+          )
+        )
+      )
+    #f
+    (none)
+    )
+  )
+
+(defstate hit (juicer)
+  :virtual #t
+  :code (behavior ()
+    (local-vars (v1-37 enemy-flag) (v1-45 enemy-flag))
+    (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 enemy-info-override hit-anim))
+                  :num! (seek!
+                    (the float
+                         (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override hit-anim)))
+                                frames
+                                num-frames
+                                )
+                            -1
+                            )
+                         )
+                    f30-0
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      )
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (let ((v1-36 (-> self enemy-flags)))
+      (if (logtest? v1-36 (enemy-flag checking-water))
+          (set! v1-37 (logior v1-36 (enemy-flag enable-on-active)))
+          (set! v1-37 (logclear v1-36 (enemy-flag enable-on-active)))
+          )
+      )
+    (set! (-> self enemy-flags) v1-37)
+    (if (logtest? (-> self enemy-flags) (enemy-flag look-at-move-dest))
+        (set! (-> self mask) (logior (process-mask collectable) (-> self mask)))
+        (logclear! (-> self mask) (process-mask collectable))
+        )
+    (let ((v1-44 (-> self enemy-flags)))
+      (if (logtest? (enemy-flag no-initial-move-to-ground) v1-44)
+          (set! v1-45 (logior (enemy-flag check-water-backup) v1-44))
+          (set! v1-45 (logclear v1-44 (enemy-flag check-water-backup)))
+          )
+      )
+    (set! (-> self enemy-flags) v1-45)
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (logclear! (-> self focus-status) (focus-status hit))
+    (go-virtual hostile)
+    (none)
+    )
+  )
+
+(defstate stare (juicer)
+  :virtual #t
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 1))
+    (let ((f30-0 (get-rand-float-range self 0.9 1.1))
+          (gp-0 (-> self draw art-group data (-> self enemy-info-override idle-anim)))
+          )
+      (until #f
+        (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))
+          )
+        )
+      )
+    #f
+    (none)
+    )
+  )
+
+(defstate taunt (juicer)
+  :virtual #t
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.6))
+    (let ((f30-0 (get-rand-float-range self 0.8 1.2)))
+      (let ((gp-0 (get-rand-int-range self 60 210))
+            (s5-0 (-> self clock frame-counter))
+            (f28-0 f30-0)
+            )
+        (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override idle-anim))
+                    :num! (loop! f28-0)
+                    :frame-num 0.0
+                    )
+        (until (>= (- (-> self clock frame-counter) s5-0) gp-0)
+          (suspend)
+          (ja :num! (loop! f28-0))
+          )
+        )
+      (ja-channel-push! 1 (seconds 0.1))
+      (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override taunt-anim))
+                  :num! (seek!
+                    (the float
+                         (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override taunt-anim)))
+                                frames
+                                num-frames
+                                )
+                            -1
+                            )
+                         )
+                    f30-0
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      )
+    (go-virtual stare)
+    (none)
+    )
+  )
+
+(defmethod enemy-method-77 juicer ((obj juicer) (arg0 (pointer float)))
+  (local-vars (a2-2 int))
+  (case (-> obj incoming knocked-type)
+    (((knocked-type knocked-type-4))
+     (ja-channel-push! 1 0)
+     (let* ((a2-0 (ash 1 (-> *juicer-global-info* prev-yellow-hit)))
+            (v1-3 (enemy-method-120 obj 4 a2-0))
+            (a1-6 (-> obj draw art-group data (-> *juicer-global-info* yellow-hit-anim v1-3)))
+            )
+       (set! (-> *juicer-global-info* prev-yellow-hit) v1-3)
+       (let ((a0-13 (-> obj skel root-channel 0)))
+         (set! (-> a0-13 frame-group) (the-as art-joint-anim a1-6))
+         (set! (-> a0-13 param 0) (the float (+ (-> (the-as art-joint-anim a1-6) frames num-frames) -1)))
+         (set! (-> a0-13 param 1) (-> arg0 0))
+         (set! (-> a0-13 frame-num) 0.0)
+         (joint-control-channel-group! a0-13 (the-as art-joint-anim a1-6) num-func-seek!)
+         )
+       )
+     )
+    (((knocked-type knocked-type-6))
+     (let ((v1-11 (ash 1 (-> *juicer-global-info* prev-blue-hit))))
+       (if (zero? (-> obj charge-index))
+           (set! a2-2 (logior v1-11 56))
+           (set! a2-2 (logior v1-11 7))
+           )
+       )
+     (let* ((v1-15 (enemy-method-120 obj 6 a2-2))
+            (s5-1 (-> obj draw art-group data (-> *juicer-global-info* blue-hit-anim v1-15)))
+            )
+       (set! (-> *juicer-global-info* prev-blue-hit) v1-15)
+       (let ((v1-18 (if (> (-> obj skel active-channels) 0)
+                        (-> obj skel root-channel 0 frame-group)
+                        )
+                    )
+             )
+         (if (and v1-18 (= v1-18 (-> obj draw art-group data 32)))
+             (ja-channel-push! 1 (seconds 0.17))
+             (ja-channel-push! 1 (seconds 0.02))
+             )
+         )
+       (let ((a0-32 (-> obj skel root-channel 0)))
+         (set! (-> a0-32 frame-group) (the-as art-joint-anim s5-1))
+         (set! (-> a0-32 param 0) (the float (+ (-> (the-as art-joint-anim s5-1) frames num-frames) -1)))
+         (set! (-> a0-32 param 1) 1.0)
+         (set! (-> a0-32 frame-num) 0.0)
+         (joint-control-channel-group! a0-32 (the-as art-joint-anim s5-1) num-func-seek!)
+         )
+       )
+     )
+    (else
+      (let ((s4-1 (-> obj draw art-group data (-> *juicer-global-info* knocked-anim (get-rand-int obj 2)))))
+        (ja-channel-push! 1 (seconds 0.17))
+        (let ((a0-37 (-> obj skel root-channel 0)))
+          (set! (-> a0-37 frame-group) (the-as art-joint-anim s4-1))
+          (set! (-> a0-37 param 0) (the float (+ (-> (the-as art-joint-anim s4-1) frames num-frames) -1)))
+          (set! (-> a0-37 param 1) (-> arg0 0))
+          (set! (-> a0-37 frame-num) 0.0)
+          (joint-control-channel-group! a0-37 (the-as art-joint-anim s4-1) num-func-seek!)
+          )
+        )
+      )
+    )
+  #t
+  )
+
+(defmethod enemy-method-78 juicer ((obj juicer) (arg0 (pointer float)))
+  (cond
+    ((= (-> obj incoming knocked-type) (knocked-type knocked-type-6))
+     (when (>= (-> obj incoming blue-juggle-count) (the-as uint 2))
+       (let ((s4-0 (-> obj draw art-group data 32)))
+         (ja-channel-push! 1 (seconds 0.17))
+         (let ((a0-3 (-> obj skel root-channel 0)))
+           (set! (-> a0-3 frame-group) (the-as art-joint-anim s4-0))
+           (set! (-> a0-3 param 0) (the float (+ (-> (the-as art-joint-anim s4-0) frames num-frames) -1)))
+           (set! (-> a0-3 param 1) (-> arg0 0))
+           (set! (-> a0-3 frame-num) 0.0)
+           (joint-control-channel-group! a0-3 (the-as art-joint-anim s4-0) num-func-seek!)
+           )
+         )
+       #t
+       )
+     )
+    ((!= (-> obj incoming knocked-type) (knocked-type knocked-type-4))
+     (let* ((v1-14 (if (> (-> obj skel active-channels) 0)
+                       (-> obj skel root-channel 0 frame-group)
+                       )
+                   )
+            (s4-1 (if (and v1-14 (= v1-14 (-> obj draw art-group data 18)))
+                      (-> obj draw art-group data 19)
+                      (-> obj draw art-group data 17)
+                      )
+                  )
+            )
+       (ja-channel-push! 1 (seconds 0.17))
+       (let ((a0-10 (-> obj skel root-channel 0)))
+         (set! (-> a0-10 frame-group) (the-as art-joint-anim s4-1))
+         (set! (-> a0-10 param 0) (the float (+ (-> (the-as art-joint-anim s4-1) frames num-frames) -1)))
+         (set! (-> a0-10 param 1) (-> arg0 0))
+         (set! (-> a0-10 frame-num) 0.0)
+         (joint-control-channel-group! a0-10 (the-as art-joint-anim s4-1) num-func-seek!)
+         )
+       )
+     #t
+     )
+    )
+  )
+
+;; WARN: Return type mismatch symbol vs none.
+(defmethod juicer-method-184 juicer ((obj juicer) (arg0 symbol))
+  (let ((v1-1 (-> obj root-override2 root-prim)))
+    (dotimes (a0-1 (the-as int (-> v1-1 specific 0)))
+      (let ((a2-1 (-> (the-as collide-shape-prim-group v1-1) child a0-1)))
+        (if arg0
+            (logior! (-> a2-1 prim-core action) (collide-action deadly))
+            (logclear! (-> a2-1 prim-core action) (collide-action deadly))
+            )
+        )
+      )
+    )
+  (none)
+  )
+
+;; WARN: Return type mismatch none vs symbol.
+(defmethod enemy-method-63 juicer ((obj juicer) (arg0 process-focusable) (arg1 symbol))
+  (let ((t9-0 (method-of-type nav-enemy enemy-method-63)))
+    (the-as symbol (if (t9-0 obj arg0 arg1)
+                       (set-dst-proc! (-> obj los) (-> obj focus handle))
+                       )
+            )
+    )
+  )
+
+(defmethod enemy-method-114 juicer ((obj juicer))
+  "@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 6) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 7))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec enemy))
+      (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 deadly no-standon))
+      (set! (-> s4-0 transform-index) 21)
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 -4096.0 18432.0)
+      (set! (-> s5-0 root-prim) s4-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 enemy))
+      (set! (-> v1-14 prim-core collide-with)
+            (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list)
+            )
+      (set! (-> v1-14 prim-core action) (collide-action solid no-standon))
+      (set-vector! (-> v1-14 local-sphere) 0.0 6144.0 0.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 enemy))
+      (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) 6)
+      (set-vector! (-> v1-16 local-sphere) 0.0 0.0 0.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 enemy))
+      (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) 16)
+      (set-vector! (-> v1-18 local-sphere) 0.0 0.0 0.0 2048.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 enemy))
+      (set! (-> v1-20 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-20 prim-core action) (collide-action solid))
+      (set! (-> v1-20 transform-index) 11)
+      (set-vector! (-> v1-20 local-sphere) 0.0 0.0 0.0 2048.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 enemy))
+      (set! (-> v1-22 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-22 prim-core action) (collide-action solid))
+      (set! (-> v1-22 transform-index) 34)
+      (set-vector! (-> v1-22 local-sphere) 0.0 0.0 0.0 2048.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 enemy))
+      (set! (-> v1-24 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-24 prim-core action) (collide-action solid))
+      (set! (-> v1-24 transform-index) 20)
+      (set-vector! (-> v1-24 local-sphere) 0.0 0.0 0.0 2048.0)
+      )
+    (set! (-> s5-0 nav-radius) 8192.0)
+    (let ((v1-26 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-26 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-26 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 process-focusable vs juicer.
+(defmethod relocate juicer ((obj juicer) (arg0 int))
+  (if (nonzero? (-> obj intro-path))
+      (&+! (-> obj intro-path) arg0)
+      )
+  (if (nonzero? (-> obj joint))
+      (&+! (-> obj joint) arg0)
+      )
+  (the-as
+    juicer
+    ((the-as (function process-focusable int process-focusable) (find-parent-method juicer 7)) obj arg0)
+    )
+  )
+
+(defmethod enemy-method-115 juicer ((obj juicer))
+  "@abstract"
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-juicer" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (enemy-method-113 obj *juicer-nav-enemy-info*)
+  (let ((v1-5 (-> obj neck)))
+    (set! (-> v1-5 up) (the-as uint 1))
+    (set! (-> v1-5 nose) (the-as uint 2))
+    (set! (-> v1-5 ear) (the-as uint 0))
+    (set-vector! (-> v1-5 twist-max) 11832.889 11832.889 0.0 1.0)
+    (set! (-> v1-5 ignore-angle) 30947.555)
+    )
+  (let ((v1-7 (-> obj nav)))
+    (set! (-> v1-7 speed-scale) 1.0)
+    )
+  0
+  (set-gravity-length (-> obj root-override2 dynam) 573440.0)
+  (set! (-> obj last-fire-time) 0)
+  (set! (-> obj heading) (the-as basic (if (rand-vu-percent? 0.5)
+                                           #t
+                                           #f
+                                           )
+                                 )
+        )
+  (set! (-> obj move-angle) 5461.3335)
+  (set! (-> obj torso-track-player) #f)
+  (new-source! (-> obj los) obj (seconds 0.2) (collide-spec backgnd obstacle))
+  (set! (-> obj joint) (new 'process 'joint-mod (joint-mod-mode joint-set*-world) obj 5))
+  (set! (-> obj using-turn-anim) #f)
+  (let ((v1-18 (new 'process 'path-control obj 'intro 0.0 (the-as entity #f) #t)))
+    (set! (-> obj intro-path) v1-18)
+    (if (nonzero? v1-18)
+        (logior! (-> v1-18 flags) (path-control-flag display draw-line draw-point draw-text))
+        )
+    )
+  (add-connection
+    *part-engine*
+    obj
+    34
+    obj
+    318
+    (new 'static 'vector :x 901.12 :y -1146.88 :z 1269.76 :w 163840.0)
+    )
+  (add-connection
+    *part-engine*
+    obj
+    34
+    obj
+    318
+    (new 'static 'vector :x -901.12 :y -1146.88 :z 1269.76 :w 163840.0)
+    )
+  (add-connection *part-engine* obj 20 obj 4635 (new 'static 'vector :w 163840.0))
+  (set! (-> obj root-override2 pause-adjust-distance) 81920.0)
+  (set! (-> obj current-projectile) (the-as handle #f))
+  0
+  (none)
+  )
diff --git a/goal_src/jak2/levels/atoll/sniper.gc b/goal_src/jak2/levels/atoll/sniper.gc
index 9c3355e2dc..6144cc0c02 100644
--- a/goal_src/jak2/levels/atoll/sniper.gc
+++ b/goal_src/jak2/levels/atoll/sniper.gc
@@ -7,3 +7,273 @@
 
 ;; DECOMP BEGINS
 
+(deftype sniper (spyder)
+  ((next-pick-time time-frame  :offset-assert 944)
+   )
+  :heap-base #x340
+  :method-count-assert 186
+  :size-assert         #x3b8
+  :flag-assert         #xba034003b8
+  )
+
+
+(define *sniper-nav-enemy-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #t
+    :use-victory #t
+    :use-jump-blocked #t
+    :debug-draw-neck #f
+    :jump-debug-draw #f
+    :move-to-ground #t
+    :hover-if-no-ground #f
+    :idle-anim-script (new 'static 'array idle-control-frame 2
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x4 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 4
+    :notice-anim 6
+    :hostile-anim 8
+    :hit-anim 15
+    :knocked-anim 16
+    :knocked-land-anim 20
+    :die-anim 12
+    :die-falling-anim 11
+    :victory-anim 7
+    :jump-wind-up-anim 14
+    :jump-in-air-anim 14
+    :jump-land-anim 23
+    :neck-joint 6
+    :look-at-joint 7
+    :bullseye-joint 5
+    :sound-hit (static-sound-name "sniper-hit")
+    :sound-die (static-sound-name "sniper-die")
+    :notice-distance (meters 1)
+    :notice-distance-delta (meters 10)
+    :proximity-notice-distance (meters 1)
+    :default-hit-points 12
+    :gnd-collide-with (collide-spec backgnd)
+    :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.8
+    :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 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 131072.0
+    :knocked-red-vy-lo 94208.0
+    :knocked-red-vy-hi 139264.0
+    :knocked-blue-vxz-lo 40960.0
+    :knocked-blue-vxz-hi 49152.0
+    :knocked-blue-vy-lo 57344.0
+    :knocked-blue-vy-hi 98304.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 #t
+    :use-pacing #t
+    :walk-anim 5
+    :turn-anim -1
+    :run-anim 8
+    :taunt-anim -1
+    :run-travel-speed (meters 12)
+    :run-acceleration (meters 1)
+    :run-turning-acceleration (meters 50)
+    :walk-travel-speed (meters 4)
+    :walk-acceleration (meters 1)
+    :walk-turning-acceleration (meters 3)
+    :maximum-rotation-rate (degrees 360.0)
+    :notice-nav-radius (meters 1)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 20480.0
+    :circle-dist-hi 61440.0
+    :nav-mesh #f
+    )
+  )
+
+(set! (-> *sniper-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+(defmethod run-logic? sniper ((obj sniper))
+  (let ((f0-0 573440.0))
+    (>= (* f0-0 f0-0) (vector-vector-distance-squared (-> obj root-override2 trans) (camera-pos)))
+    )
+  )
+
+(defmethod enemy-method-129 sniper ((obj sniper))
+  (let ((a0-1 *target*))
+    (if a0-1
+        (set! (-> obj focus handle) (process->handle a0-1))
+        (set! (-> obj focus handle) (the-as handle #f))
+        )
+    )
+  (set! (-> obj focus aware) (if (>= (vector-vector-distance (-> obj root-override2 trans) (camera-pos))
+                                     (-> obj fact-info-override idle-distance)
+                                     )
+                                 (enemy-aware enemy-aware-0)
+                                 (enemy-aware enemy-aware-1)
+                                 )
+        )
+  (none)
+  )
+
+(defmethod nav-enemy-method-156 sniper ((obj sniper))
+  (let ((s4-0 (-> obj path curve num-cverts)))
+    (if (<= s4-0 0)
+        (go process-drawable-art-error "no path")
+        )
+    (let ((s2-0 (get-rand-int obj s4-0))
+          (gp-0 (new 'stack-no-clear 'vector))
+          )
+      (countdown (s3-0 s4-0)
+        (get-point-in-path! (-> obj path) gp-0 (the float s2-0) 'interp)
+        (if (< 409.6 (vector-vector-xz-distance gp-0 (-> obj root-override2 trans)))
+            (goto cfg-9)
+            )
+        (set! s2-0 (mod (+ s2-0 1) s4-0))
+        )
+      (label cfg-9)
+      (let ((v1-16 (-> obj nav state)))
+        (logclear! (-> v1-16 flags) (nav-state-flag directional-mode))
+        (logior! (-> v1-16 flags) (nav-state-flag target-poly-dirty))
+        (set! (-> v1-16 target-post quad) (-> gp-0 quad))
+        )
+      )
+    )
+  0
+  0
+  (none)
+  )
+
+(defstate active (sniper)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type spyder active) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self next-pick-time) (-> self clock frame-counter))
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (let ((f30-0 (get-rand-float-range self 0.9 1.1)))
+      (until #f
+        (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override walk-anim))
+                    :num! (seek!
+                      (the float
+                           (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override walk-anim)))
+                                  frames
+                                  num-frames
+                                  )
+                              -1
+                              )
+                           )
+                      f30-0
+                      )
+                    :frame-num 0.0
+                    )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek! max f30-0))
+          )
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (when (or (logtest? (-> self nav state flags) (nav-state-flag at-target))
+              (nav-enemy-method-163 self)
+              (>= (-> self clock frame-counter) (-> self next-pick-time))
+              )
+      (nav-enemy-method-156 self)
+      (nav-enemy-method-162 self)
+      (set! (-> self next-pick-time) (+ (-> self clock frame-counter) (get-rand-int-range self 300 1050)))
+      )
+    (nav-enemy-method-176 self)
+    (none)
+    )
+  )
+
+(defmethod enemy-method-115 sniper ((obj sniper))
+  "@abstract"
+  (let ((t9-0 (method-of-type spyder enemy-method-115)))
+    (t9-0 obj)
+    )
+  (enemy-method-112 obj *sniper-nav-enemy-info*)
+  (logior! (-> obj focus-status) (focus-status ignore))
+  (logclear! (-> obj focus-status) (focus-status dangerous))
+  (logclear! (-> obj enemy-flags) (enemy-flag check-water))
+  0
+  (none)
+  )
+
+(defmethod enemy-method-114 sniper ((obj sniper))
+  "@abstract"
+  (let ((t9-0 (method-of-type spyder enemy-method-114)))
+    (t9-0 obj)
+    )
+  (let ((v1-2 (-> obj root-override2 root-prim)))
+    (set! (-> v1-2 prim-core collide-as) (collide-spec))
+    (set! (-> v1-2 prim-core collide-with) (collide-spec))
+    )
+  (set! (-> obj root-override2 backup-collide-as) (collide-spec))
+  (set! (-> obj root-override2 backup-collide-with) (collide-spec))
+  0
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod go-idle sniper ((obj sniper))
+  (with-pp
+    (cond
+      ((eval!
+         (new 'stack 'script-context (the-as basic (process->ppointer pp)) pp (the-as vector #f))
+         (res-lump-struct (-> obj entity) 'on-activate pair)
+         )
+       (cleanup-for-death obj)
+       (go (method-of-object obj die-fast))
+       )
+      (else
+        (go (method-of-object obj idle))
+        )
+      )
+    (none)
+    )
+  )
diff --git a/goal_src/jak2/levels/city/common/transport.gc b/goal_src/jak2/levels/city/common/transport.gc
index 327f96fc59..6bd17f2877 100644
--- a/goal_src/jak2/levels/city/common/transport.gc
+++ b/goal_src/jak2/levels/city/common/transport.gc
@@ -5,5 +5,575 @@
 ;; name in dgo: transport
 ;; dgos: CWI
 
+(define-extern ctywide-entity-hack (function none))
+
 ;; DECOMP BEGINS
 
+(defskelgroup skel-vehicle-turret vehicle-turret vehicle-turret-lod0-jg vehicle-turret-idle-ja
+              ((vehicle-turret-lod0-mg (meters 20))
+               (vehicle-turret-lod1-mg (meters 40))
+               (vehicle-turret-lod2-mg (meters 999999))
+               )
+              :bounds (static-spherem 0 0 0 2)
+              )
+
+(define *transport-turret-state-info* (new 'static 'traffic-guard-type-settings
+                                        :acquire-delay #x1c2
+                                        :shot-delay #x4b
+                                        :burst-delay #x384
+                                        :shot-count 2
+                                        :rand-shot-count 1
+                                        )
+        )
+
+(deftype vehicle-turret (process-focusable)
+  ((turret-jm joint-mod              :offset-assert 204)
+   (turret    turret-control :inline :offset-assert 208)
+   (target    handle                 :offset-assert 288)
+   )
+  :heap-base #xb0
+  :method-count-assert 31
+  :size-assert         #x128
+  :flag-assert         #x1f00b00128
+  (:methods
+    (idle () _type_ :state 27)
+    (vehicle-turret-method-28 (_type_) none 28)
+    (vehicle-turret-method-29 (_type_) none 29)
+    (vehicle-turret-method-30 (_type_) none 30)
+    )
+  )
+
+
+(defmethod vehicle-turret-method-29 vehicle-turret ((obj vehicle-turret))
+  (let* ((s4-0 (ppointer->process (-> obj parent)))
+         (s5-0 (if (type? s4-0 process-focusable)
+                   s4-0
+                   )
+               )
+         )
+    (when s5-0
+      (let ((a2-0 (matrix<-transformq!
+                    (new 'stack-no-clear 'matrix)
+                    (the-as transformq (-> (the-as process-drawable s5-0) root trans))
+                    )
+                  )
+            )
+        (vector-matrix*! (-> obj root-override trans) (new 'static 'vector :y 8601.6 :z 12288.0 :w 1.0) a2-0)
+        )
+      (quaternion-copy! (-> obj root-override quat) (-> (the-as process-drawable s5-0) root quat))
+      )
+    )
+  0
+  (none)
+  )
+
+(defstate idle (vehicle-turret)
+  :virtual #t
+  :trans (behavior ()
+    (turret-control-method-12 (-> self turret) (the-as joint-mod-rotate-local (-> self turret-jm)))
+    (vehicle-turret-method-29 self)
+    (when (and (nonzero? (-> self target)) (handle->process (-> self target)))
+      (let* ((s5-0 (handle->process (-> self target)))
+             (gp-0 (if (type? s5-0 process-focusable)
+                       s5-0
+                       )
+                   )
+             (s5-1 (new 'stack-no-clear 'vector))
+             )
+        (set! (-> s5-1 quad) (-> (get-trans (the-as process-focusable gp-0) 3) quad))
+        (turret-control-method-11
+          (-> self turret)
+          self
+          s5-1
+          (-> (the-as process-focusable gp-0) root-override transv)
+          )
+        )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior vehicle-turret) sleep-code)
+  :post (the-as (function none :behavior vehicle-turret) transform-post)
+  )
+
+(defmethod vehicle-turret-method-28 vehicle-turret ((obj vehicle-turret))
+  (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 ((v1-6 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-6 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-6 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-6 prim-core action) (collide-action solid))
+      (set! (-> v1-6 transform-index) 3)
+      (set-vector! (-> v1-6 local-sphere) 0.0 0.0 0.0 4096.0)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) v1-6)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-9 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-9 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-9 prim-core collide-with))
+      )
+    (set! (-> obj root-override) s5-0)
+    )
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch process-drawable vs vehicle-turret.
+(defmethod relocate vehicle-turret ((obj vehicle-turret) (arg0 int))
+  (if (nonzero? (-> obj turret-jm))
+      (&+! (-> obj turret-jm) arg0)
+      )
+  (the-as
+    vehicle-turret
+    ((the-as (function process-drawable int process-drawable) (find-parent-method vehicle-turret 7)) obj arg0)
+    )
+  )
+
+(defmethod vehicle-turret-method-30 vehicle-turret ((obj vehicle-turret))
+  (set! (-> obj turret-jm)
+        (the-as joint-mod (new 'process 'joint-mod-rotate-local obj (-> obj turret info joint-index) #t))
+        )
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior vehicle-turret-init-by-other vehicle-turret ((arg0 turret-control-info))
+  (vehicle-turret-method-28 self)
+  (turret-control-method-15 (-> self turret) arg0)
+  (logior! (-> self turret flags) (turret-flag targetting-laser no-rot-y-clamp))
+  (vehicle-turret-method-29 self)
+  (vector-identity! (-> self root-override scale))
+  (vector-float*! (-> self root-override scale) (-> self root-override scale) 2.0)
+  (ctywide-entity-hack)
+  (initialize-skeleton
+    self
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-vehicle-turret" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (vehicle-turret-method-30 self)
+  (set! (-> self turret guard-settings) *transport-turret-state-info*)
+  (go-virtual idle)
+  (none)
+  )
+
+(define *transport-turret-control-info* (new 'static 'turret-control-info
+                                          :joint-index 3
+                                          :barrel-count 1
+                                          :shot-speed 819200.0
+                                          :attack-range 102400.0
+                                          :rot-min (new 'static 'array float 2 -16384.0 -2184533.2)
+                                          :rot-max (new 'static 'array float 2 0.0 2184533.2)
+                                          :local-pos (new 'static 'vector :y -1433.6 :z 4096.0 :w 1.0)
+                                          :local-dir (new 'static 'vector :z 1.0 :w 1.0)
+                                          :barrel-array (new 'static 'inline-array turret-barrel-info 4
+                                            (new 'static 'turret-barrel-info
+                                              :local-pos (new 'static 'vector :y -1433.6 :z 4096.0 :w 1.0)
+                                              :local-dir (new 'static 'vector :z 1.0 :w 1.0)
+                                              )
+                                            (new 'static 'turret-barrel-info)
+                                            (new 'static 'turret-barrel-info)
+                                            (new 'static 'turret-barrel-info)
+                                            )
+                                          )
+        )
+
+(deftype transport-params (structure)
+  ((spawn-pos vector     :inline :offset-assert   0)
+   (quat      quaternion :inline :offset-assert  16)
+   (nav-mesh  nav-mesh           :offset-assert  32)
+   (max-guard uint32             :offset-assert  36)
+   (max-time  float              :offset-assert  40)
+   (turret?   symbol             :offset-assert  44)
+   (speeches? symbol             :offset-assert  48)
+   )
+  :method-count-assert 9
+  :size-assert         #x34
+  :flag-assert         #x900000034
+  )
+
+
+(deftype transport (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)
+   (ambient-sound-id      uint32      :offset-assert 252)
+   (turret                handle      :offset-assert 256)
+   )
+  :heap-base #x90
+  :method-count-assert 36
+  :size-assert         #x108
+  :flag-assert         #x2400900108
+  (:methods
+    (come-down () _type_ :state 27)
+    (idle () _type_ :state 28)
+    (leave () _type_ :state 29)
+    (die-fast () _type_ :state 30)
+    (transport-method-31 (_type_) none 31)
+    (transport-method-32 (_type_) none 32)
+    (transport-method-33 (_type_) none 33)
+    (transport-method-34 (_type_ process) none 34)
+    (transport-method-35 (_type_) none 35)
+    )
+  )
+
+
+(defskelgroup skel-transport 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)
+              )
+
+(defbehavior transport-event-handler transport ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (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))
+     )
+    (('stop-spawning)
+     (set! (-> self spawn?) #f)
+     #f
+     )
+    )
+  )
+
+(defmethod run-logic? transport ((obj transport))
+  #t
+  )
+
+(defmethod transport-method-35 transport ((obj transport))
+  (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)
+  )
+
+(defmethod deactivate transport ((obj transport))
+  (sound-stop (the-as sound-id (-> obj ambient-sound-id)))
+  ((the-as (function process-drawable none) (find-parent-method transport 10)) obj)
+  (none)
+  )
+
+(defstate come-down (transport)
+  :virtual #t
+  :event transport-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! transport-idle-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim transport-idle-ja) 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-method-35 self)
+    (transform-post)
+    (none)
+    )
+  )
+
+(defstate idle (transport)
+  :virtual #t
+  :event transport-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 ()
+    (transport-method-34 self (the-as process #f))
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 0)
+    (sound-play "tran-door-open")
+    (ja-no-eval :group! transport-hatch-open-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim transport-hatch-open-ja) 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-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-method-34 self *target*)
+    (transport-method-35 self)
+    (transform-post)
+    (none)
+    )
+  )
+
+(defstate die-fast (transport)
+  :virtual #t
+  :code (behavior ()
+    (sound-stop (the-as sound-id (-> self ambient-sound-id)))
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+(defstate leave (transport)
+  :virtual #t
+  :event transport-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! transport-hatch-close-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim transport-hatch-close-ja) 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-method-35 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-method-33 transport ((obj transport))
+  (with-pp
+    (when (>= (- (-> pp clock frame-counter) (-> obj last-guard-spawn-time)) 0)
+      (let ((s5-0 (new 'stack 'traffic-object-spawn-params)))
+        (set! (-> s5-0 object-type) (the-as uint 6))
+        (set! (-> s5-0 behavior) (the-as uint 6))
+        (set! (-> s5-0 id) (the-as uint 0))
+        (set! (-> s5-0 nav-mesh) (-> obj nav-mesh))
+        (set! (-> s5-0 nav-branch) #f)
+        (set! (-> s5-0 proc) #f)
+        (set! (-> s5-0 handle) (the-as uint (process->handle obj)))
+        (set! (-> s5-0 user-data) (-> obj spawn-side))
+        (set! (-> s5-0 flags) (the-as uint 0))
+        (set! (-> s5-0 guard-type) (the-as uint 7))
+        (vector-reset! (-> s5-0 velocity))
+        (set! (-> s5-0 position quad) (-> obj root-override trans quad))
+        (set! (-> s5-0 position y) (+ 8192.0 (-> s5-0 position y)))
+        (quaternion-rotate-local-y! (-> s5-0 rotation) (-> obj root-override quat) 32768.0)
+        (send-event *traffic-manager* 'activate-object s5-0)
+        (when (-> s5-0 proc)
+          (set! (-> obj spawn-side) (- 1 (the-as int (-> obj spawn-side))))
+          (if (logtest? (-> obj draw status) (draw-control-status on-screen))
+              (set! (-> obj last-guard-spawn-time) (+ (-> pp clock frame-counter) (seconds 1)))
+              (set! (-> obj last-guard-spawn-time) (+ (-> pp clock frame-counter) (seconds 2)))
+              )
+          (+! (-> obj count-guard) 1)
+          )
+        (when (not (-> s5-0 proc))
+          (if (logtest? (-> obj draw status) (draw-control-status on-screen))
+              (set! (-> obj last-guard-spawn-time) (+ (-> pp clock frame-counter) (seconds 0.1)))
+              (set! (-> obj last-guard-spawn-time) (+ (-> pp clock frame-counter) (seconds 1)))
+              )
+          )
+        )
+      )
+    (none)
+    )
+  )
+
+(defmethod transport-method-34 transport ((obj transport) (arg0 process))
+  (let ((v1-1 (handle->process (-> obj turret))))
+    (if v1-1
+        (set! (-> (the-as vehicle-turret v1-1) target) (process->handle arg0))
+        )
+    )
+  0
+  (none)
+  )
+
+(defmethod transport-method-31 transport ((obj transport))
+  (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-method-32 transport ((obj transport))
+  (set! (-> obj spawn-side) (the-as uint 0))
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior transport-init-by-other transport ((arg0 transport-params))
+  (transport-method-31 self)
+  (set! (-> self root-override trans quad) (-> arg0 spawn-pos quad))
+  (quaternion-copy! (-> self root-override quat) (-> arg0 quat))
+  (vector-identity! (-> self root-override scale))
+  (set! (-> self max-guard) (-> arg0 max-guard))
+  (set! (-> self count-guard) (the-as uint 0))
+  (set! (-> self nav-mesh) (-> arg0 nav-mesh))
+  (set! (-> self max-time) 0.0)
+  (initialize-skeleton
+    self
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-transport" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (transport-method-32 self)
+  (set! (-> self y-dest) (-> self root-override trans y))
+  (set! (-> self root-override trans y) (+ 163840.0 (-> self root-override trans y)))
+  (set! (-> self spawn?) #t)
+  (set! (-> self leave-time) 0)
+  (if (-> arg0 turret?)
+      (set! (-> self turret)
+            (ppointer->handle (process-spawn vehicle-turret *transport-turret-control-info* :to self))
+            )
+      (set! (-> self turret) (the-as handle #f))
+      )
+  (set! (-> self ambient-sound-id) (the-as uint (new-sound-id)))
+  (go-virtual come-down)
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! transport ((obj transport) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (transport-method-31 obj)
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-transport" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (transport-method-32 obj)
+  (set! (-> obj spawn?) #t)
+  (go (method-of-object obj come-down))
+  (none)
+  )
diff --git a/goal_src/jak2/levels/city/common/vehicle-guard.gc b/goal_src/jak2/levels/city/common/vehicle-guard.gc
index 3d4da4cfe1..d428742142 100644
--- a/goal_src/jak2/levels/city/common/vehicle-guard.gc
+++ b/goal_src/jak2/levels/city/common/vehicle-guard.gc
@@ -7,3 +7,81 @@
 
 ;; DECOMP BEGINS
 
+(deftype turret-barrel-info (structure)
+  ((local-pos vector :inline :offset-assert 0)
+   (local-dir vector :inline :offset-assert 16)
+   )
+  :method-count-assert 9
+  :size-assert         #x20
+  :flag-assert         #x900000020
+  )
+
+(deftype turret-control-info (structure)
+  ((joint-index  int8            :offset-assert 0)
+   (barrel-count int8            :offset-assert 1)
+   (shot-speed   float           :offset-assert 4)
+   (attack-range float           :offset-assert 8)
+   (rot-min      float 2       :offset-assert 12)
+   (rot-max      float 2       :offset-assert 20)
+   (rot-x-min    float           :offset 12)
+   (rot-x-max    float           :offset 20)
+   (rot-y-min    float           :offset 16)
+   (rot-y-max    float           :offset 24)
+   (local-pos    vector  :inline :offset-assert 32)
+   (local-dir    vector  :inline :offset-assert 48)
+   (barrel-array turret-barrel-info 4    :inline   :offset-assert 64)
+   )
+  :method-count-assert 9
+  :size-assert         #xc0
+  :flag-assert         #x9000000c0
+  )
+
+(defenum turret-flag
+    :bitfield #t
+    :type uint8
+    (firing 0)
+    (aiming 1)
+    (should-shoot 2)
+    (targetting-laser 3)
+    (display-marks 4)
+    (no-rot-y-clamp 5)
+    )
+
+(deftype turret-control (structure)
+  (
+    (info                 turret-control-info         :offset-assert 0)
+    (guard-settings       traffic-guard-type-settings :offset-assert 4)
+    (flags                turret-flag                     :offset-assert 8)
+    (shot-count           int8                        :offset-assert 9)
+    (burst-count          int16                       :offset-assert 10)
+    (target-dist          float                       :offset-assert 12)
+    (inaccuracy           float                       :offset-assert 16)
+    (aim-offset-angle     degrees                     :offset-assert 20)
+    (aim-rot              float 2                     :offset-assert 24) ;; elt size: 4
+    (aim-rot-vel          float 2                     :offset-assert 32) ;; elt size: 4
+    (aim-rot-offset       float 2                     :offset-assert 40) ;; elt size: -8
+    (aim-rot-x            float                       :offset 24)
+    (aim-rot-y            float                       :offset 28)
+    (aim-rot-vel-x        float                       :offset 32)
+    (aim-rot-vel-y        float                       :offset 36)
+    (target-in-sight-time time-frame                  :offset-assert 48)
+    (aim-acquire-time     time-frame                  :offset-assert 56)
+    (shoot-time           time-frame                  :offset-assert 64)
+    (owner-handle         handle                       :offset-assert 72)
+  )
+  :pack-me
+  :method-count-assert 18
+  :size-assert         #x50
+  :flag-assert         #x1200000050
+  (:methods
+    (turret-control-method-9 (_type_ vehicle vector vector) none 9)
+    (turret-control-method-10 (_type_ vehicle) none 10)
+    (turret-control-method-11 (_type_ object object vector) none 11)
+    (turret-control-method-12 (_type_ joint-mod-rotate-local) none 12)
+    (turret-control-method-13 (_type_) none 13)
+    (turret-control-method-14 (_type_) none 14)
+    (turret-control-method-15 (_type_ turret-control-info) none 15)
+    (turret-control-method-16 (_type_ float float) none 16)
+    (turret-control-method-17 (_type_ vehicle) none 17)
+    )
+  )
\ No newline at end of file
diff --git a/goal_src/jak2/levels/city/farm/yakow.gc b/goal_src/jak2/levels/city/farm/yakow.gc
index 354a8d8100..ccbcaf0a80 100644
--- a/goal_src/jak2/levels/city/farm/yakow.gc
+++ b/goal_src/jak2/levels/city/farm/yakow.gc
@@ -7,3 +7,448 @@
 
 ;; DECOMP BEGINS
 
+(defskelgroup skel-yakow yakow yakow-lod0-jg yakow-idle-ja
+              ((yakow-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 1 0 4)
+              )
+
+(deftype yakow (nav-enemy)
+  ((incoming-attack-id uint32  :offset-assert 604)
+   (grazing            basic   :offset-assert 608)
+   )
+  :heap-base #x1f0
+  :method-count-assert 179
+  :size-assert         #x264
+  :flag-assert         #xb301f00264
+  (:methods
+    (kicked () _type_ :state 178)
+    )
+  )
+
+
+(define *yakow-nav-enemy-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #f
+    :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 idle-control-frame 4
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x3 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 3
+    :notice-anim 3
+    :hostile-anim 6
+    :hit-anim 3
+    :knocked-anim 7
+    :knocked-land-anim 7
+    :die-anim -1
+    :die-falling-anim -1
+    :victory-anim -1
+    :jump-wind-up-anim -1
+    :jump-in-air-anim -1
+    :jump-land-anim -1
+    :neck-joint 5
+    :look-at-joint 6
+    :bullseye-joint 4
+    :sound-hit (static-sound-name "yakow-hit")
+    :sound-die (static-sound-name "yakow-die")
+    :notice-distance (meters 30)
+    :notice-distance-delta (meters 10)
+    :default-hit-points 5
+    :gnd-collide-with (collide-spec backgnd)
+    :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.8
+    :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 2730.6667
+    :knocked-soft-vxz-lo 16384.0
+    :knocked-soft-vxz-hi 16384.0
+    :knocked-soft-vy-lo 16384.0
+    :knocked-soft-vy-hi 16384.0
+    :knocked-medium-vxz-lo 16384.0
+    :knocked-medium-vxz-hi 16384.0
+    :knocked-medium-vy-lo 16384.0
+    :knocked-medium-vy-hi 16384.0
+    :knocked-hard-vxz-lo 16384.0
+    :knocked-hard-vxz-hi 16384.0
+    :knocked-hard-vy-lo 16384.0
+    :knocked-hard-vy-hi 16384.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 16384.0
+    :knocked-yellow-vxz-hi 16384.0
+    :knocked-yellow-vy-lo 16384.0
+    :knocked-yellow-vy-hi 16384.0
+    :knocked-red-vxz-lo 16384.0
+    :knocked-red-vxz-hi 16384.0
+    :knocked-red-vy-lo 16384.0
+    :knocked-red-vy-hi 16384.0
+    :knocked-blue-vxz-lo 16384.0
+    :knocked-blue-vxz-hi 16384.0
+    :knocked-blue-vy-lo 16384.0
+    :knocked-blue-vy-hi 16384.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)
+    :callback-info #f
+    :use-momentum #t
+    :use-frustration #f
+    :use-stop-chase #f
+    :use-circling #f
+    :use-pacing #f
+    :walk-anim 5
+    :turn-anim -1
+    :run-anim 6
+    :taunt-anim -1
+    :run-travel-speed (meters 6)
+    :run-acceleration (meters 1)
+    :run-turning-acceleration (meters 1)
+    :walk-travel-speed (meters 2.13)
+    :walk-acceleration (meters 1)
+    :walk-turning-acceleration (meters 1)
+    :maximum-rotation-rate (degrees 50.000004)
+    :notice-nav-radius (meters 1)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 20480.0
+    :circle-dist-hi 61440.0
+    :nav-mesh #f
+    )
+  )
+
+(set! (-> *yakow-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+(defmethod enemy-method-56 yakow ((obj yakow) (arg0 process) (arg1 event-message-block))
+  0
+  )
+
+(defmethod enemy-method-74 yakow ((obj yakow) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (case arg2
+    (('attack)
+     (let ((v1-1 (the-as object (-> arg3 param 1))))
+       (when (!= (-> (the-as attack-info v1-1) id) (-> obj incoming-attack-id))
+         (set! (-> obj incoming-attack-id) (-> (the-as attack-info v1-1) id))
+         (go (method-of-object obj kicked))
+         )
+       )
+     )
+    (else
+      ((method-of-type nav-enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+      )
+    )
+  )
+
+(defmethod enemy-method-123 yakow ((obj yakow) (arg0 float))
+  "TODO"
+  (>= arg0 (rand-vu))
+  )
+
+;; WARN: Function (method 156 yakow) has a return type of none, but the expression builder found a return statement.
+(defmethod nav-enemy-method-156 yakow ((obj yakow))
+  (dotimes (s5-0 16)
+    (let ((f30-1 (* 4096.0 (get-rand-float-range obj -10.0 10.0)))
+          (f0-2 (* 4096.0 (get-rand-float-range obj -10.0 10.0)))
+          (s4-0 (new 'stack-no-clear 'vector))
+          )
+      (set! (-> s4-0 quad) (-> obj root-override2 trans quad))
+      (+! (-> s4-0 x) f30-1)
+      (+! (-> s4-0 z) f0-2)
+      (let ((v1-7 (-> obj nav))
+            (a0-6 s4-0)
+            (a1-2 (new 'stack-no-clear 'nav-find-poly-parms))
+            )
+        (vector-! (-> a1-2 point) a0-6 (-> v1-7 state mesh bounds))
+        (set! (-> a1-2 y-threshold) (-> v1-7 nearest-y-threshold))
+        (set! (-> a1-2 ignore) (the-as uint 2))
+        (when (find-poly-containing-point-local (-> v1-7 state mesh) a1-2)
+          (let ((v1-12 (-> obj nav state)))
+            (logclear! (-> v1-12 flags) (nav-state-flag directional-mode))
+            (logior! (-> v1-12 flags) (nav-state-flag target-poly-dirty))
+            (set! (-> v1-12 target-post quad) (-> s4-0 quad))
+            )
+          0
+          (return #f)
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+(defstate idle (yakow)
+  :virtual #t
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.15))
+    (until #f
+      (let ((f30-0 (rand-vu-float-range 0.9 1.1)))
+        (ja-no-eval :group! yakow-idle-ja
+                    :num! (seek! (the float (+ (-> (the-as art-joint-anim yakow-idle-ja) frames num-frames) -1)) f30-0)
+                    :frame-num 0.0
+                    )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek! max f30-0))
+          )
+        )
+      (when (rand-vu-percent? 0.25)
+        (ja-channel-push! 1 (seconds 0.1))
+        (ja-no-eval :group! yakow-graze-ja
+                    :num! (seek! (the float (+ (-> (the-as art-joint-anim yakow-graze-ja) frames num-frames) -1)))
+                    :frame-num 0.0
+                    )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek!))
+          )
+        (ja-channel-push! 1 (seconds 0.1))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (if (and (nonzero? (-> self draw)) (logtest? (-> self draw status) (draw-control-status on-screen)))
+        (set! (-> self last-draw-time) (the-as uint (-> self clock frame-counter)))
+        )
+    (enemy-method-129 self)
+    (ja-post)
+    (none)
+    )
+  )
+
+(defstate active (yakow)
+  :virtual #t
+  :trans (behavior ()
+    (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1))
+      (if (< (the-as int (-> self focus aware)) 1)
+          (go-virtual idle)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (let ((f30-0 (get-rand-float-range self 0.9 1.1)))
+      (until #f
+        (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override walk-anim))
+                    :num! (seek!
+                      (the float
+                           (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override walk-anim)))
+                                  frames
+                                  num-frames
+                                  )
+                              -1
+                              )
+                           )
+                      f30-0
+                      )
+                    :frame-num 0.0
+                    )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek! max f30-0))
+          )
+        (when (enemy-method-123 self 0.2)
+          (ja-no-eval :num! (loop!))
+          (ja-channel-push! 1 (seconds 0.6))
+          (let ((v1-37 self))
+            (set! (-> v1-37 enemy-flags) (the-as enemy-flag (logclear (-> v1-37 enemy-flags) (enemy-flag enemy-flag36))))
+            (set! (-> v1-37 nav callback-info) *nav-enemy-null-callback-info*)
+            )
+          0
+          (nav-enemy-method-167 self)
+          (until #f
+            (let ((f28-0 (rand-vu-float-range 0.9 1.1)))
+              (ja-no-eval :group! yakow-idle-ja
+                          :num! (seek! (the float (+ (-> (the-as art-joint-anim yakow-idle-ja) frames num-frames) -1)) f28-0)
+                          :frame-num 0.0
+                          )
+              (until (ja-done? 0)
+                (suspend)
+                (ja :num! (seek! max f28-0))
+                )
+              )
+            (when (rand-vu-percent? 0.25)
+              (ja-channel-push! 1 (seconds 0.1))
+              (ja-no-eval :group! yakow-graze-ja
+                          :num! (seek! (the float (+ (-> (the-as art-joint-anim yakow-graze-ja) frames num-frames) -1)))
+                          :frame-num 0.0
+                          )
+              (until (ja-done? 0)
+                (suspend)
+                (ja :num! (seek!))
+                )
+              (ja-channel-push! 1 (seconds 0.1))
+              )
+            (if (enemy-method-123 self 0.2)
+                (goto cfg-15)
+                )
+            )
+          #f
+          (label cfg-15)
+          (let ((v1-97 (-> self nav state)))
+            (set! (-> v1-97 speed) 0.0)
+            )
+          0
+          (let ((a0-23 (-> self nav state))
+                (v1-100 *null-vector*)
+                )
+            (set! (-> a0-23 velocity quad) (-> v1-100 quad))
+            )
+          0
+          (let ((v1-103 self))
+            (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-103 enemy-flags)))
+                (set! (-> v1-103 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-103 enemy-flags))))
+                )
+            (set! (-> v1-103 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-103 enemy-flags))))
+            (set! (-> v1-103 nav callback-info) (-> v1-103 enemy-info-override callback-info))
+            )
+          0
+          (nav-enemy-method-165 self)
+          (ja-no-eval :num! (loop!))
+          (ja-channel-push! 1 (seconds 0.6))
+          (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override walk-anim))
+                      :num! (seek!
+                        (the float
+                             (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override walk-anim)))
+                                    frames
+                                    num-frames
+                                    )
+                                -1
+                                )
+                             )
+                        f30-0
+                        )
+                      :frame-num 0.0
+                      )
+          (until (ja-done? 0)
+            (ja-blend-eval)
+            (suspend)
+            (ja :num! (seek! max f30-0))
+            )
+          )
+        )
+      )
+    #f
+    (none)
+    )
+  )
+
+(defstate kicked (yakow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior yakow) #f)
+  :enter (behavior ()
+    (let ((v1-0 self))
+      (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logclear (-> v1-0 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-0 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :exit (behavior ()
+    '()
+    (none)
+    )
+  :trans (behavior ()
+    '()
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.05))
+    (ja-no-eval :group! yakow-kicked-in-place-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim yakow-kicked-in-place-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (go-virtual active)
+    (none)
+    )
+  :post (the-as (function none :behavior yakow) ja-post)
+  )
+
+(defmethod enemy-method-114 yakow ((obj yakow))
+  "@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 ((v1-7 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-7 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-7 prim-core collide-with) (collide-spec backgnd jak player-list))
+      (set! (-> v1-7 prim-core action) (collide-action solid no-standon))
+      (set-vector! (-> v1-7 local-sphere) 0.0 4096.0 0.0 10240.0)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) v1-7)
+      )
+    (set! (-> s5-0 nav-radius) 10240.0)
+    (let ((v1-9 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-9 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-9 prim-core collide-with))
+      )
+    (set! (-> s5-0 max-iteration-count) (the-as uint 3))
+    (set! (-> obj root-override2) s5-0)
+    )
+  0
+  (none)
+  )
+
+(defmethod enemy-method-115 yakow ((obj yakow))
+  "@abstract"
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-yakow" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (enemy-method-113 obj *yakow-nav-enemy-info*)
+  (let ((v1-5 (-> obj nav)))
+    (set! (-> v1-5 speed-scale) 1.0)
+    )
+  0
+  (set-gravity-length (-> obj root-override2 dynam) 327680.0)
+  0
+  (none)
+  )
diff --git a/goal_src/jak2/levels/city/slums/kor/kid-h.gc b/goal_src/jak2/levels/city/slums/kor/kid-h.gc
index 10b6f72633..a37988b8ff 100644
--- a/goal_src/jak2/levels/city/slums/kor/kid-h.gc
+++ b/goal_src/jak2/levels/city/slums/kor/kid-h.gc
@@ -7,3 +7,44 @@
 
 ;; DECOMP BEGINS
 
+(deftype kid (bot)
+  ((travel-anim-interp  float       :offset-assert 992)
+   (arrest-attempt-time time-frame  :offset-assert 1000)
+   (arrestor-handle     handle      :offset-assert 1008)
+   )
+  :heap-base #x380
+  :method-count-assert 235
+  :size-assert         #x3f8
+  :flag-assert         #xeb038003f8
+  (:methods
+    (traveling () _type_ :state 225)
+    (traveling-blocked () _type_ :state 226)
+    (waiting-with-kor () _type_ :state 227)
+    (waiting-idle () _type_ :state 228)
+    (waiting-turn () _type_ :state 229)
+    (scared-idle () _type_ :state 230)
+    (arrested () _type_ :state 231)
+    (kid-method-232 (_type_) none 232)
+    (kid-method-233 (_type_) none 233)
+    (kid-method-234 (_type_) none 234)
+    )
+  )
+
+
+(defskelgroup skel-kid kid 0 3
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 0 0 2)
+              :shadow 2
+              :origin-joint-index 13
+              )
+
+(deftype kidt-wait-spot (ai-task)
+  ((check-done   (function kidt-wait-spot kid symbol)   :offset  32)
+   (which-spot   int8                                   :offset  36)
+   (num-spots    uint8                                  :offset  37)
+   (spot-indexes uint8                                6 :offset  38)
+   )
+  :method-count-assert 12
+  :size-assert         #x30
+  :flag-assert         #xc00000030
+  )
diff --git a/goal_src/jak2/levels/city/slums/kor/kid-states.gc b/goal_src/jak2/levels/city/slums/kor/kid-states.gc
index fce64c31bb..fa25d2b4a6 100644
--- a/goal_src/jak2/levels/city/slums/kor/kid-states.gc
+++ b/goal_src/jak2/levels/city/slums/kor/kid-states.gc
@@ -5,5 +5,646 @@
 ;; name in dgo: kid-states
 ;; dgos: CTYKORA
 
+(declare-type crimson-guard citizen)
+
 ;; DECOMP BEGINS
 
+(defstate waiting-idle (kid)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kid) 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
+    (nav-enemy-method-167 self)
+    (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))
+    (enemy-method-109 self 1)
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (b!
+      (not (and (-> self focus-info fproc) (>= (fabs (-> self focus-info ry-diff)) 9102.223)))
+      cfg-6
+      :delay (empty-form)
+      )
+    (kid-method-233 self)
+    (b! #t cfg-15 :delay (nop!))
+    (label cfg-6)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (if (if (type? gp-0 process-focusable)
+              gp-0
+              )
+          (go-virtual arrested)
+          )
+      )
+    (label cfg-15)
+    (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+      (if (not (outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #f))
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((v1-2 (ja-group)))
+      (cond
+        ((and v1-2 (= v1-2 (-> self draw art-group data 3)))
+         (ja-no-eval :num! (seek!))
+         (while (not (ja-done? 0))
+           (suspend)
+           (ja-eval)
+           )
+         )
+        (else
+          (ja-channel-push! 1 (seconds 0.2))
+          )
+        )
+      )
+    (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 (the-as (function none :behavior kid) nav-enemy-simple-post)
+  )
+
+(defstate waiting-turn (kid)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kid) 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
+    (nav-enemy-method-167 self)
+    (let ((v1-7 self))
+      (set! (-> v1-7 enemy-flags) (the-as enemy-flag (logclear (-> v1-7 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (enemy-method-109 self 1)
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+      (if (and (not (outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #f))
+               (let ((gp-0 (handle->process (-> self arrestor-handle))))
+                 (not (if (type? gp-0 process-focusable)
+                          gp-0
+                          )
+                      )
+                 )
+               )
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (local-vars (s4-1 art-element) (f0-9 float))
+    (let ((gp-0 (new 'stack-no-clear 'bot-turn-info)))
+      (let ((s5-0 (-> self focus-info fproc)))
+        (if (not s5-0)
+            (kid-method-232 self)
+            )
+        (turn-to-target self gp-0 s5-0 0.8)
+        )
+      (let ((s4-0 (>= (-> gp-0 predicted-ry-diff) 0.0)))
+        (let ((s5-1 (-> self draw art-group data (if s4-0
+                                                     7
+                                                     11
+                                                     )
+                        )
+                    )
+              )
+          (ja-channel-push! 1 (seconds 0.4))
+          (ja-no-eval :group! s5-1
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim s5-1) frames num-frames) -1)))
+                      :frame-num 0.0
+                      )
+          )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek!))
+          )
+        (let ((a2-3 (-> self focus-info fproc)))
+          (if a2-3
+              (turn-to-target self gp-0 a2-3 0.533)
+              )
+          )
+        (let ((s5-2 (new 'stack-no-clear 'quaternion))
+              (f0-8 (-> gp-0 predicted-ry-diff))
+              (f30-0 5.0)
+              (f28-0 7.0)
+              )
+          (cond
+            (s4-0
+              (if (< f0-8 0.0)
+                  (set! f0-8 (+ 65536.0 f0-8))
+                  )
+              (cond
+                ((< f0-8 18204.445)
+                 (set! f0-9 9102.223)
+                 (set! s4-1 (-> self draw art-group data 8))
+                 (set! f28-0 8.0)
+                 )
+                ((< f0-8 27306.666)
+                 (set! f0-9 18204.445)
+                 (set! s4-1 (-> self draw art-group data 9))
+                 )
+                (else
+                  (set! f0-9 27306.666)
+                  (set! s4-1 (-> self draw art-group data 10))
+                  )
+                )
+              )
+            (else
+              (if (>= f0-8 0.0)
+                  (set! f0-8 (+ -65536.0 f0-8))
+                  )
+              (cond
+                ((< -18204.445 f0-8)
+                 (set! f0-9 -9102.223)
+                 (set! s4-1 (-> self draw art-group data 12))
+                 (set! f28-0 8.0)
+                 )
+                ((< -27306.666 f0-8)
+                 (set! f0-9 -18204.445)
+                 (set! s4-1 (-> self draw art-group data 13))
+                 )
+                (else
+                  (set! f0-9 -27306.666)
+                  (set! s4-1 (-> self draw art-group data 14))
+                  )
+                )
+              )
+            )
+          (quaternion-rotate-y! s5-2 (-> gp-0 src-quat) f0-9)
+          (ja-no-eval :group! s4-1
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim s4-1) frames num-frames) -1)))
+                      :frame-num 0.0
+                      )
+          (until (ja-done? 0)
+            (let ((f0-14 (ja-aframe-num 0)))
+              (cond
+                ((< f0-14 f28-0)
+                 (if (>= f0-14 f30-0)
+                     (quaternion-slerp! (-> self root-override2 quat) (-> gp-0 src-quat) s5-2 (/ (- f0-14 f30-0) (- f28-0 f30-0)))
+                     )
+                 )
+                (else
+                  (quaternion-copy! (-> self root-override2 quat) s5-2)
+                  )
+                )
+              )
+            (suspend)
+            (ja :num! (seek!))
+            )
+          )
+        )
+      )
+    (kid-method-232 self)
+    (none)
+    )
+  :post (the-as (function none :behavior kid) nav-enemy-simple-post)
+  )
+
+(defstate waiting-with-kor (kid)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kid) enemy-event-handler)
+  :enter (-> (method-of-type kid waiting-idle) enter)
+  :exit (-> (method-of-type kid waiting-idle) exit)
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+      (if (not (outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #f))
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (-> (method-of-type kid waiting-idle) code)
+  :post (-> (method-of-type kid waiting-idle) post)
+  )
+
+(defstate scared-idle (kid)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kid) 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
+    (nav-enemy-method-167 self)
+    (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))
+    (enemy-method-109 self 1)
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (b!
+      (not (and (-> self focus-info fproc) (>= (fabs (-> self focus-info ry-diff)) 9102.223)))
+      cfg-6
+      :delay (empty-form)
+      )
+    (kid-method-233 self)
+    (b! #t cfg-15 :delay (nop!))
+    (label cfg-6)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (if (if (type? gp-0 process-focusable)
+              gp-0
+              )
+          (go-virtual arrested)
+          )
+      )
+    (label cfg-15)
+    (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+      (if (not (outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #f))
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((v1-2 (ja-group)))
+      (cond
+        ((and v1-2 (= v1-2 (-> self draw art-group data 4)))
+         (ja-no-eval :num! (seek!))
+         (while (not (ja-done? 0))
+           (suspend)
+           (ja-eval)
+           )
+         )
+        (else
+          (ja-channel-push! 1 (seconds 0.2))
+          )
+        )
+      )
+    (until #f
+      (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!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior kid) nav-enemy-simple-post)
+  )
+
+(defstate traveling (kid)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kid) enemy-event-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (let ((v1-2 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-2 enemy-flags)))
+          (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-2 enemy-flags))))
+          )
+      (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-2 enemy-flags))))
+      (set! (-> v1-2 nav callback-info) (-> v1-2 enemy-info-override callback-info))
+      )
+    0
+    (let ((v1-5 self))
+      (set! (-> v1-5 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-5 enemy-flags))))
+      )
+    0
+    (enemy-method-110 self)
+    (nav-enemy-method-166 self)
+    (set! (-> self player-blocking) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (cond
+        ((if (type? gp-0 process-focusable)
+             gp-0
+             )
+         (go-virtual arrested)
+         )
+        ((outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #t)
+         (kid-method-232 self)
+         )
+        ((and (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.5)) (bot-method-208 self))
+         (go-virtual traveling-blocked)
+         )
+        ((and (nav-enemy-method-163 self)
+              (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+              )
+         (go-stare2 self)
+         )
+        )
+      )
+    0
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (kid-method-234 self)
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (let ((a0-0 (-> self nav state))
+          (v1-1 (-> self spot))
+          )
+      (logclear! (-> a0-0 flags) (nav-state-flag directional-mode))
+      (logior! (-> a0-0 flags) (nav-state-flag target-poly-dirty))
+      (set! (-> a0-0 target-post quad) (-> v1-1 center quad))
+      )
+    0
+    (nav-enemy-travel-post)
+    (none)
+    )
+  )
+
+(defstate traveling-blocked (kid)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kid) 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
+    (nav-enemy-method-167 self)
+    (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))
+    (enemy-method-109 self 1)
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (cond
+        ((if (type? gp-0 process-focusable)
+             gp-0
+             )
+         (go-virtual arrested)
+         )
+        ((and (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1)) (not (bot-method-208 self)))
+         (go-virtual traveling)
+         )
+        )
+      )
+    (none)
+    )
+  :code (-> (method-of-type kid waiting-idle) code)
+  :post (the-as (function none :behavior kid) nav-enemy-simple-post)
+  )
+
+(defstate stare (kid)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type bot stare) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (let ((v1-4 self))
+      (set! (-> v1-4 enemy-flags) (the-as enemy-flag (logclear (-> v1-4 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (if (if (type? gp-0 process-focusable)
+              gp-0
+              )
+          (go-virtual arrested)
+          )
+      )
+    (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1))
+      (if (not (nav-enemy-method-163 self))
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (-> (method-of-type kid waiting-idle) code)
+  )
+
+(defstate hit (kid)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type bot hit) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :code (behavior ()
+    (local-vars (v1-31 enemy-flag) (v1-39 enemy-flag))
+    (ja-channel-push! 1 (seconds 0.1))
+    (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!))
+      )
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (let ((v1-30 (-> self enemy-flags)))
+      (if (logtest? v1-30 (enemy-flag checking-water))
+          (set! v1-31 (logior v1-30 (enemy-flag enable-on-active)))
+          (set! v1-31 (logclear v1-30 (enemy-flag enable-on-active)))
+          )
+      )
+    (set! (-> self enemy-flags) v1-31)
+    (if (logtest? (-> self enemy-flags) (enemy-flag look-at-move-dest))
+        (set! (-> self mask) (logior (process-mask collectable) (-> self mask)))
+        (logclear! (-> self mask) (process-mask collectable))
+        )
+    (let ((v1-38 (-> self enemy-flags)))
+      (if (logtest? (enemy-flag no-initial-move-to-ground) v1-38)
+          (set! v1-39 (logior (enemy-flag check-water-backup) v1-38))
+          (set! v1-39 (logclear v1-38 (enemy-flag check-water-backup)))
+          )
+      )
+    (set! (-> self enemy-flags) v1-39)
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (logclear! (-> self focus-status) (focus-status hit))
+    (enemy-method-72 self)
+    (none)
+    )
+  )
+
+(defstate knocked (kid)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type bot knocked) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  )
+
+(defstate arrested (kid)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kid) 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
+    (nav-enemy-method-167 self)
+    (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))
+    (enemy-method-110 self)
+    (set! (-> self travel-anim-interp) 0.0)
+    (if (logtest? (bot-flags bf20) (-> self bot-flags))
+        (logclear! (-> self enemy-flags) (enemy-flag enable-on-active checking-water))
+        )
+    (none)
+    )
+  :trans (behavior ()
+    (cond
+      ((logtest? (-> self bot-flags) (bot-flags bf09))
+       (fail-falling self)
+       )
+      (else
+        (bot-method-223 self #f)
+        (when (not (logtest? (bot-flags bf20) (-> self bot-flags)))
+          (if (and (-> self focus-info fproc) (>= (fabs (-> self focus-info ry-diff)) 9102.223))
+              (kid-method-233 self)
+              )
+          (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+            (let ((gp-0 (handle->process (-> self arrestor-handle))))
+              (if (not (if (type? gp-0 process-focusable)
+                           gp-0
+                           )
+                       )
+                  (enemy-method-72 self)
+                  )
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (when (not (logtest? (bot-flags bf20) (-> self bot-flags)))
+      (ja-channel-push! 1 (seconds 0.1))
+      (ja-no-eval :group! (-> self draw art-group data 15)
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 15)) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    (fail-mission! self)
+    (let* ((gp-0 (handle->process (-> self arrestor-handle)))
+           (v1-32 (if (type? gp-0 process-focusable)
+                      gp-0
+                      )
+                  )
+           )
+      (if v1-32
+          (logclear! (-> (the-as crimson-guard v1-32) enemy-flags) (enemy-flag enable-on-active checking-water))
+          )
+      )
+    (let ((v1-35 (ja-group)))
+      (if (not (and v1-35 (= v1-35 (-> self draw art-group data 15))))
+          (ja-channel-push! 1 (seconds 0.1))
+          )
+      )
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (until #f
+      (ja-no-eval :group! (-> self draw art-group data 16)
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 16)) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (if (and (logtest? (-> self bot-flags) (bot-flags failed))
+                 (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 4))
+                 (reset? *fail-mission-control*)
+                 )
+            (reset! *fail-mission-control*)
+            )
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior kid) nav-enemy-simple-post)
+  )
+
+(defstate failed (kid)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self bot-flags) (logior (bot-flags bf20) (-> self bot-flags)))
+    ((-> (method-of-type kid arrested) enter))
+    (none)
+    )
+  :trans (-> (method-of-type kid arrested) trans)
+  :code (-> (method-of-type kid arrested) code)
+  :post (-> (method-of-type kid arrested) post)
+  )
+
+(defstate die-falling (kid)
+  :virtual #t
+  :enter (-> (method-of-type kid failed) enter)
+  :trans (-> (method-of-type kid failed) trans)
+  :code (-> (method-of-type kid failed) code)
+  )
diff --git a/goal_src/jak2/levels/city/slums/kor/kid-task.gc b/goal_src/jak2/levels/city/slums/kor/kid-task.gc
index c727f4033a..9782741f90 100644
--- a/goal_src/jak2/levels/city/slums/kor/kid-task.gc
+++ b/goal_src/jak2/levels/city/slums/kor/kid-task.gc
@@ -7,3 +7,44 @@
 
 ;; DECOMP BEGINS
 
+(defmethod reset-task! kidt-wait-spot ((obj kidt-wait-spot))
+  "Virtual"
+  (set! (-> obj check-done) #f)
+  (set! (-> obj which-spot) -1)
+  (set! (-> obj num-spots) (the-as uint 0))
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch symbol vs none.
+(defmethod ai-task-method-11 kidt-wait-spot ((obj kidt-wait-spot) (arg0 bot))
+  "Virtual"
+  (let ((s4-0 (-> obj which-spot)))
+    (when (>= s4-0 0)
+      (let ((s3-0 (-> arg0 course spots (-> obj spot-indexes s4-0))))
+        (if (and (not (outside-spot-radius? arg0 s3-0 (the-as vector #f) #f)) (player-blocking-spot? arg0 s3-0))
+            (set! s4-0 -1)
+            )
+        )
+      )
+    (when (< s4-0 0)
+      (set! s4-0 (choose-spot arg0 (the-as int (-> obj num-spots)) (the-as (pointer uint) (-> obj spot-indexes))))
+      (set! (-> obj which-spot) s4-0)
+      (mem-copy!
+        (the-as pointer (-> arg0 spot))
+        (the-as pointer (-> arg0 course spots (-> obj spot-indexes s4-0)))
+        20
+        )
+      )
+    (if (logtest? *display-bot-marks* (bot-marks-controls bmc16))
+        (bot-debug-draw-spot-sphere
+          arg0
+          (the-as int (-> obj num-spots))
+          (the-as (pointer uint) (-> obj spot-indexes))
+          (the-as int (-> obj spot-indexes s4-0))
+          )
+        )
+    )
+  ((-> obj check-done) obj (the-as kid arg0))
+  (none)
+  )
diff --git a/goal_src/jak2/levels/city/slums/kor/kid.gc b/goal_src/jak2/levels/city/slums/kor/kid.gc
index e60202bae7..6f91544d61 100644
--- a/goal_src/jak2/levels/city/slums/kor/kid.gc
+++ b/goal_src/jak2/levels/city/slums/kor/kid.gc
@@ -7,3 +7,577 @@
 
 ;; DECOMP BEGINS
 
+(define *kid-nav-enemy-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 idle-control-frame 2
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x3 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 3
+    :notice-anim 3
+    :hostile-anim -1
+    :hit-anim 3
+    :knocked-anim 17
+    :knocked-land-anim 18
+    :die-anim 3
+    :die-falling-anim 3
+    :victory-anim -1
+    :jump-wind-up-anim 3
+    :jump-in-air-anim 3
+    :jump-land-anim 3
+    :neck-joint 6
+    :look-at-joint 6
+    :bullseye-joint 4
+    :notice-distance (meters 30)
+    :notice-distance-delta (meters 10)
+    :proximity-notice-distance (meters 30)
+    :default-hit-points 100
+    :gnd-collide-with (collide-spec backgnd)
+    :overlaps-others-collide-with-filter (collide-spec jak civilian enemy vehicle-sphere hit-by-others-list player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.7
+    :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 2730.6667
+    :knocked-soft-vxz-lo 40960.0
+    :knocked-soft-vxz-hi 40960.0
+    :knocked-soft-vy-lo 12288.0
+    :knocked-soft-vy-hi 12288.0
+    :knocked-medium-vxz-lo 40960.0
+    :knocked-medium-vxz-hi 40960.0
+    :knocked-medium-vy-lo 12288.0
+    :knocked-medium-vy-hi 12288.0
+    :knocked-hard-vxz-lo 40960.0
+    :knocked-hard-vxz-hi 40960.0
+    :knocked-hard-vy-lo 12288.0
+    :knocked-hard-vy-hi 12288.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 40960.0
+    :knocked-yellow-vxz-hi 40960.0
+    :knocked-yellow-vy-lo 12288.0
+    :knocked-yellow-vy-hi 12288.0
+    :knocked-red-vxz-lo 40960.0
+    :knocked-red-vxz-hi 40960.0
+    :knocked-red-vy-lo 12288.0
+    :knocked-red-vy-hi 12288.0
+    :knocked-blue-vxz-lo 40960.0
+    :knocked-blue-vxz-hi 40960.0
+    :knocked-blue-vy-lo 12288.0
+    :knocked-blue-vy-hi 12288.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 #t
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #f
+    :use-pacing #f
+    :walk-anim 3
+    :turn-anim -1
+    :run-anim 3
+    :taunt-anim -1
+    :run-travel-speed (meters 5.5)
+    :run-acceleration (meters 5)
+    :run-turning-acceleration (meters 6)
+    :walk-travel-speed (meters 1.5)
+    :walk-acceleration (meters 5)
+    :walk-turning-acceleration (meters 6)
+    :maximum-rotation-rate (degrees 180.0)
+    :notice-nav-radius (meters 0.85)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 20480.0
+    :circle-dist-hi 61440.0
+    :nav-mesh #f
+    )
+  )
+
+(set! (-> *kid-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+(defmethod enemy-method-74 kid ((obj kid) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (with-pp
+    (case arg2
+      (('arrest)
+       (let* ((s4-0 (handle->process (-> obj arrestor-handle)))
+              (v1-4 (if (type? s4-0 process-focusable)
+                        s4-0
+                        )
+                    )
+              )
+         (when (or (not v1-4)
+                   (= v1-4 arg0)
+                   (and (!= v1-4 arg0) (>= (- (-> pp clock frame-counter) (-> obj arrest-attempt-time)) (seconds 0.1)))
+                   )
+           (set! (-> obj arrestor-handle) (process->handle arg0))
+           (set! (-> obj arrest-attempt-time) (-> pp clock frame-counter))
+           0
+           )
+         )
+       #t
+       )
+      (('instant-arrest)
+       (set! (-> obj bot-flags) (logior (bot-flags bf20) (-> obj bot-flags)))
+       (let ((v1-18 (the-as object (-> arg3 param 0))))
+         (set! (-> obj arrestor-handle) (process->handle (the-as process v1-18)))
+         (set! (-> obj arrest-attempt-time) (-> pp clock frame-counter))
+         (let ((a1-8 (new 'stack-no-clear 'vector)))
+           (vector-! a1-8 (-> (the-as process-drawable v1-18) root trans) (-> obj root-override2 trans))
+           (set! (-> a1-8 y) 0.0)
+           (forward-up->quaternion (-> obj root-override2 quat) a1-8 *up-vector*)
+           )
+         )
+       (logclear! (-> obj enemy-flags) (enemy-flag enable-on-active checking-water))
+       (logclear! (-> obj mask) (process-mask collectable))
+       (logclear! (-> obj enemy-flags) (enemy-flag look-at-move-dest))
+       (logclear! (-> obj mask) (process-mask actor-pause))
+       (logclear! (-> obj enemy-flags) (enemy-flag notice))
+       (send-event (handle->process (-> obj master-handle)) 'notify 'arrest #f)
+       (go (method-of-object obj arrested))
+       )
+      (('attack)
+       ((method-of-type bot enemy-method-74) obj arg0 arg1 arg2 arg3)
+       #f
+       )
+      (else
+        ((method-of-type bot enemy-method-74) obj arg0 arg1 arg2 arg3)
+        )
+      )
+    )
+  )
+
+(defmethod enemy-method-97 kid ((obj kid))
+  (with-pp
+    (let* ((s4-0 (handle->process (-> obj attacker-handle)))
+           (s5-0 (if (type? s4-0 process-focusable)
+                     s4-0
+                     )
+                 )
+           (s3-0 (handle->process (-> obj arrestor-handle)))
+           (s4-1 (if (type? s3-0 process-focusable)
+                     s3-0
+                     )
+                 )
+           )
+      (when s5-0
+        (cond
+          ((= (-> s5-0 type) target)
+           (when (or (not (logtest? (-> obj bot-flags) (bot-flags attacked)))
+                     (>= (- (-> pp clock frame-counter) (-> obj attacker-time)) (seconds 1.5))
+                     )
+             (if (logtest? (-> obj bot-flags) (bot-flags attacked))
+                 (reset-attacker! obj)
+                 )
+             (set! s5-0 (the-as process #f))
+             (set! (-> obj attacker-handle) (the-as handle #f))
+             )
+           )
+          (else
+            (when (>= (- (-> pp clock frame-counter) (-> obj attacker-time)) (seconds 6))
+              (set! s5-0 (the-as process #f))
+              (set! (-> obj attacker-handle) (the-as handle #f))
+              )
+            )
+          )
+        )
+      (when s4-1
+        (when (or (>= (- (-> pp clock frame-counter) (-> obj arrest-attempt-time)) (seconds 0.5))
+                  (logtest? (-> (the-as process-focusable s4-1) focus-status) (focus-status dead hit))
+                  )
+          (set! s4-1 (the-as process #f))
+          (set! (-> obj arrestor-handle) (the-as handle #f))
+          )
+        )
+      (let ((v1-34 (-> obj focus-mode))
+            (s3-1 (the-as process #f))
+            )
+        (cond
+          ((zero? v1-34)
+           (cond
+             (s4-1
+               (set! s3-1 s4-1)
+               )
+             (s5-0
+               (set! s3-1 s5-0)
+               )
+             ((begin (set! s3-1 (select-focus! obj)) s3-1)
+              (empty)
+              )
+             (else
+               (let ((s5-1 (handle->process (-> obj poi-handle))))
+                 (set! s3-1 (if (type? s5-1 process-focusable)
+                                s5-1
+                                )
+                       )
+                 )
+               (if s3-1
+                   (empty)
+                   (set! s3-1 *target*)
+                   )
+               )
+             )
+           )
+          ((= v1-34 1)
+           (cond
+             (s4-1
+               (set! s3-1 s4-1)
+               )
+             (s5-0
+               (set! s3-1 s5-0)
+               )
+             (else
+               (let ((s5-2 (handle->process (-> obj poi-handle))))
+                 (set! s3-1 (if (type? s5-2 process-focusable)
+                                s5-2
+                                )
+                       )
+                 )
+               (cond
+                 (s3-1
+                   (empty)
+                   )
+                 ((begin (set! s3-1 (select-focus! obj)) s3-1)
+                  (empty)
+                  )
+                 (else
+                   (set! s3-1 *target*)
+                   )
+                 )
+               )
+             )
+           )
+          )
+        (cond
+          (s3-1
+            (try-update-focus (-> obj focus) (the-as process-focusable s3-1) obj)
+            (if (and (logtest? (-> obj bot-flags) (bot-flags attacked)) (!= (-> s3-1 type) target))
+                (logclear! (-> obj bot-flags) (bot-flags attacked))
+                )
+            )
+          (else
+            (clear-focused (-> obj focus))
+            (logclear! (-> obj bot-flags) (bot-flags attacked))
+            )
+          )
+        s3-1
+        )
+      )
+    )
+  )
+
+(defmethod alive? kid ((obj kid))
+  (let ((t9-0 (method-of-type bot alive?)))
+    (and (t9-0 obj)
+         (not (and (-> obj next-state) (let ((v1-4 (-> obj next-state name)))
+                                         (or (= v1-4 'arrested) (= v1-4 'die) (= v1-4 'die-falling))
+                                         )
+                   )
+              )
+         (zero? (logand (bot-flags bf20) (-> obj bot-flags)))
+         )
+    )
+  )
+
+(defmethod enemy-method-114 kid ((obj kid))
+  "@abstract"
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum hit-by-others))))
+    (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 3) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 4))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec bot bot-targetable))
+      (set! (-> s4-0 prim-core collide-with)
+            (collide-spec backgnd jak crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
+            )
+      (set! (-> s4-0 prim-core action) (collide-action solid can-ride no-standon))
+      (set-vector! (-> s4-0 local-sphere) 0.0 3276.8 0.0 4505.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 bot bot-targetable))
+      (set! (-> v1-13 prim-core collide-with)
+            (collide-spec backgnd jak crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-13 prim-core action) (collide-action solid can-ride))
+      (set-vector! (-> v1-13 local-sphere) 0.0 2048.0 0.0 2048.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 bot bot-targetable))
+      (set! (-> v1-15 prim-core collide-with)
+            (collide-spec backgnd jak crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-15 prim-core action) (collide-action solid))
+      (set-vector! (-> v1-15 local-sphere) 0.0 3584.0 0.0 2048.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 bot bot-targetable))
+      (set! (-> v1-17 prim-core collide-with)
+            (collide-spec backgnd jak crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-17 prim-core action) (collide-action solid no-standon))
+      (set-vector! (-> v1-17 local-sphere) 0.0 5120.0 0.0 2048.0)
+      )
+    (set! (-> s5-0 nav-radius) 3481.6)
+    (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! (-> s5-0 max-iteration-count) (the-as uint 3))
+    (set! (-> s5-0 event-priority) (the-as uint 3))
+    (set! (-> obj root-override2) s5-0)
+    )
+  0
+  (none)
+  )
+
+(defmethod init! kid ((obj kid))
+  "Set defaults for various fields."
+  (let ((t9-0 (method-of-type bot init!)))
+    (t9-0 obj)
+    )
+  (set! (-> obj min-speed) 6144.0)
+  (set! (-> obj max-speed) 22528.0)
+  (set! (-> obj channel) (the-as uint 26))
+  (set! (-> obj notice-enemy-dist) 122880.0)
+  (set! (-> obj travel-anim-interp) 0.0)
+  (set! (-> obj focus-info max-los-dist) 0.0)
+  (set-vector! (-> obj root-override2 scale) 1.2 1.2 1.2 1.0)
+  (set! (-> obj spot-color) (the-as uint #x60004f8f))
+  (set! (-> obj arrestor-handle) (the-as handle #f))
+  0
+  (none)
+  )
+
+(defmethod enemy-method-115 kid ((obj kid))
+  "@abstract"
+  (init! obj)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-kid" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (enemy-method-113 obj *kid-nav-enemy-info*)
+  (let ((v1-7 (-> obj neck)))
+    (set! (-> v1-7 up) (the-as uint 1))
+    (set! (-> v1-7 nose) (the-as uint 2))
+    (set! (-> v1-7 ear) (the-as uint 0))
+    (set-vector! (-> v1-7 twist-max) 11832.889 11832.889 0.0 1.0)
+    (set! (-> v1-7 ignore-angle) 30947.555)
+    )
+  (let ((t9-4 (method-of-type bot enemy-method-115)))
+    (t9-4 obj)
+    )
+  (set! (-> obj my-simple-focus) (process-spawn simple-focus :to obj))
+  0
+  (none)
+  )
+
+(defmethod bot-method-214 kid ((obj kid))
+  #f
+  )
+
+(defmethod go-hostile kid ((obj kid))
+  (kid-method-232 obj)
+  (none)
+  )
+
+(defmethod enemy-method-72 kid ((obj kid))
+  (kid-method-232 obj)
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod kid-method-233 kid ((obj kid))
+  (go (method-of-object obj waiting-turn))
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod kid-method-232 kid ((obj kid))
+  (let ((s5-0 (handle->process (-> obj arrestor-handle))))
+    (cond
+      ((if (type? s5-0 process-focusable)
+           s5-0
+           )
+       (go (method-of-object obj arrested))
+       )
+      ((logtest? (bot-flags bf19) (-> obj bot-flags))
+       (go (method-of-object obj scared-idle))
+       )
+      (else
+        (go (method-of-object obj waiting-idle))
+        )
+      )
+    )
+  (none)
+  )
+
+(defmethod kid-method-234 kid ((obj kid))
+  (with-pp
+    (let ((f30-0 (-> obj nav state speed)))
+      (let ((f0-1 (lerp-scale 0.0 1.0 f30-0 6144.0 22528.0)))
+        (seek! (-> obj travel-anim-interp) f0-1 (* 4.0 (-> pp clock seconds-per-frame)))
+        )
+      (let ((f28-0 (-> obj travel-anim-interp))
+            (v1-7 (if (> (-> obj skel active-channels) 0)
+                      (-> obj skel root-channel 0 frame-group)
+                      )
+                  )
+            )
+        (cond
+          ((and v1-7 (= v1-7 (-> obj draw art-group data 5)))
+           (let ((v1-12 (-> obj skel root-channel 1)))
+             (set! (-> v1-12 frame-interp 1) f28-0)
+             (set! (-> v1-12 frame-interp 0) f28-0)
+             )
+           (let* ((f28-1 (current-cycle-distance (-> obj skel)))
+                  (f0-5 (quaternion-y-angle (-> obj root-override2 quat)))
+                  (f1-2 (deg- f0-5 (-> obj travel-prev-ry)))
+                  (f0-8 (fmin 22528.0 (* 0.35342914 (-> pp clock frames-per-second) (fabs f1-2))))
+                  (f0-11 (/ (* 8.0 (fmax f30-0 f0-8)) (* 15.0 f28-1)))
+                  (a0-10 (-> obj skel root-channel 0))
+                  )
+             (set! (-> a0-10 param 0) f0-11)
+             (joint-control-channel-group-eval! a0-10 (the-as art-joint-anim #f) num-func-loop!)
+             )
+           (let ((a0-11 (-> obj skel root-channel 1)))
+             (set! (-> a0-11 param 0) 0.0)
+             (joint-control-channel-group-eval! a0-11 (the-as art-joint-anim #f) num-func-chan)
+             )
+           )
+          (else
+            (ja-channel-push! 2 (seconds 0.15))
+            (let ((a0-13 (-> obj skel root-channel 0)))
+              (set! (-> a0-13 dist) 3276.8)
+              (set! (-> a0-13 frame-group) (the-as art-joint-anim (-> obj draw art-group data 5)))
+              (set! (-> a0-13 param 0) 1.0)
+              (joint-control-channel-group! a0-13 (the-as art-joint-anim (-> obj draw art-group data 5)) num-func-loop!)
+              )
+            (let ((a0-14 (-> obj skel root-channel 1)))
+              (set! (-> a0-14 frame-interp 1) f28-0)
+              (set! (-> a0-14 frame-interp 0) f28-0)
+              (set! (-> a0-14 dist) 8737.997)
+              (set! (-> a0-14 frame-group) (the-as art-joint-anim (-> obj draw art-group data 6)))
+              (set! (-> a0-14 param 0) 0.0)
+              (joint-control-channel-group! a0-14 (the-as art-joint-anim (-> obj draw art-group data 6)) num-func-chan)
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  )
+
+(defmethod enemy-method-56 kid ((obj kid) (arg0 process) (arg1 event-message-block))
+  (if (= (-> obj course course-id) 7)
+      0
+      ((method-of-type bot enemy-method-56) obj arg0 arg1)
+      )
+  )
+
+(defmethod bot-method-190 kid ((obj kid))
+  #t
+  )
+
+(defmethod enemy-method-78 kid ((obj kid) (arg0 (pointer float)))
+  (ja-channel-push! 1 (seconds 0.1))
+  (let ((a1-2 (-> obj draw art-group data (-> obj enemy-info-override knocked-land-anim)))
+        (a0-4 (-> obj skel root-channel 0))
+        )
+    (set! (-> a0-4 frame-group) (the-as art-joint-anim a1-2))
+    (set! (-> a0-4 param 0) (the float (+ (-> (the-as art-joint-anim a1-2) 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-2) num-func-seek!)
+    )
+  #t
+  )
+
+;; WARN: Return type mismatch float vs meters.
+(defmethod set-cam-height! kid ((obj kid) (arg0 vector))
+  (the-as
+    meters
+    (cond
+      ((and (-> obj next-state) (= (-> obj next-state name) 'arrested))
+       (set-vector! arg0 49152.0 12288.0 49152.0 1.0)
+       (vector<-cspace+vector! arg0 (-> obj node-list data 2) arg0)
+       (if (logtest? (-> obj focus-status) (focus-status under-water))
+           (set! (-> arg0 y) (+ (get-water-height obj) (-> *setting-control* cam-current target-height)))
+           )
+       )
+      (else
+        ((method-of-type bot set-cam-height!) obj arg0)
+        )
+      )
+    )
+  )
+
+(defmethod enemy-method-102 kid ((obj kid))
+  (if (logtest? (bot-flags bf20) (-> obj bot-flags))
+      #f
+      ((method-of-type bot enemy-method-102) obj)
+      )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod go-idle kid ((obj kid))
+  (cond
+    ((= (-> obj course course-id) 7)
+     (cond
+       ((task-node-closed? (game-task-node city-help-kid-resolution))
+        (cleanup-for-death obj)
+        (go (method-of-object obj die-fast))
+        )
+       (else
+         (go (method-of-object obj waiting-with-kor))
+         )
+       )
+     )
+    (else
+      (go (method-of-object obj waiting-idle))
+      )
+    )
+  (none)
+  )
diff --git a/goal_src/jak2/levels/city/slums/kor/kid3-course.gc b/goal_src/jak2/levels/city/slums/kor/kid3-course.gc
index a51fe79f3f..138a04399e 100644
--- a/goal_src/jak2/levels/city/slums/kor/kid3-course.gc
+++ b/goal_src/jak2/levels/city/slums/kor/kid3-course.gc
@@ -7,3 +7,229 @@
 
 ;; DECOMP BEGINS
 
+;; WARN: Return type mismatch focus-status vs none.
+(defun kid-update-during-battle ((arg0 kid))
+  (let ((v1-0 *target*))
+    (if (and v1-0 (-> v1-0 next-state) (let ((v1-3 (-> v1-0 next-state name)))
+                                         (or (= v1-3 'target-darkjak-get-on) (= v1-3 'target-darkjak-get-off))
+                                         )
+             )
+        (logior! (-> arg0 focus-status) (focus-status disable))
+        (logclear! (-> arg0 focus-status) (focus-status disable))
+        )
+    )
+  (none)
+  )
+
+(define *kid3-course*
+  (new 'static 'bot-course
+    :course-id #x7
+    :spot-count #x4
+    :default-check-too-far #f
+    :waypoints (new 'static 'boxed-array :type bot-waypoint
+      (new 'static 'bot-waypoint
+        :waypoint-id 1
+        :skip-to -1
+        :on-set (lambda ((arg0 kid))
+          (process-entity-status! arg0 (entity-perm-status no-kill) #t)
+          (clear-speech-flags! arg0)
+          (logior! (-> arg0 focus-status) (focus-status disable))
+          (set! (-> arg0 notice-enemy-dist) 0.0)
+          (let ((v1-5 (-> arg0 root-override2 root-prim)))
+            (set! (-> v1-5 prim-core collide-as) (collide-spec))
+            (set! (-> v1-5 prim-core collide-with) (collide-spec))
+            )
+          0
+          (move-to-point! (-> arg0 root-override2) (the-as vector (-> arg0 course spots 0)))
+          (logclear! (-> arg0 mask) (process-mask actor-pause))
+          (logclear! (-> arg0 enemy-flags) (enemy-flag notice))
+          (let ((v1-16 (get-task-by-type (-> arg0 ai-ctrl) kidt-wait-spot arg0)))
+            (set! (-> v1-16 bytes 5) (the-as uint 1))
+            (set! (-> v1-16 bytes 6) (the-as uint 0))
+            (set! (-> v1-16 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kidt-wait-spot v1-16) check-done)
+                  (the-as
+                    (function kidt-wait-spot kid symbol)
+                    (lambda ((arg0 object) (arg1 kid)) (when (< 1 (-> arg1 waypoint-request))
+                                                         (let* ((v1-4 (-> arg1 actor-group 0 data 0 actor))
+                                                                (a0-2 (if v1-4
+                                                                          (-> v1-4 extra process)
+                                                                          )
+                                                                      )
+                                                                )
+                                                           (when a0-2
+                                                             (set! (-> arg1 master-handle) (process->handle a0-2))
+                                                             (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                                                             (go-to-waypoint! arg1 2 #f)
+                                                             (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                                                             #t
+                                                             )
+                                                           )
+                                                         )
+                            )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update #f
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 2
+        :skip-to -1
+        :on-set (lambda ((arg0 kid))
+          (let ((v1-1 (-> arg0 root-override2 root-prim)))
+            (set! (-> v1-1 prim-core collide-as) (-> arg0 root-override2 backup-collide-as))
+            (set! (-> v1-1 prim-core collide-with) (-> arg0 root-override2 backup-collide-with))
+            )
+          (logclear! (-> arg0 focus-status) (focus-status disable))
+          (let ((v1-5 (get-task-by-type (-> arg0 ai-ctrl) kidt-wait-spot arg0)))
+            (set! (-> v1-5 bytes 5) (the-as uint 1))
+            (set! (-> v1-5 bytes 6) (the-as uint 0))
+            (set! (-> v1-5 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kidt-wait-spot v1-5) check-done)
+                  (the-as
+                    (function kidt-wait-spot kid symbol)
+                    (lambda ((arg0 object) (arg1 kid))
+                      (when (>= (-> arg1 waypoint-request) 6)
+                        (set! (-> arg1 root-override2 trans quad) (-> arg1 course spots 1 center quad))
+                        (set! (-> arg1 root-override2 trans w) 1.0)
+                        (quaternion-vector-angle!
+                          (-> arg1 root-override2 quat)
+                          *up-vector*
+                          (* 182.04445 (* 0.00024414062 (-> arg1 course spots 1 center w)))
+                          )
+                        (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                        (go-to-waypoint! arg1 5 #f)
+                        (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                        #t
+                        )
+                      )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update #f
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 5
+        :skip-to -1
+        :on-set (lambda ((arg0 kid))
+          (set! (-> arg0 focus-status) (logior (focus-status arrestable) (-> arg0 focus-status)))
+          (set! (-> arg0 bot-flags) (logior (bot-flags bf19) (-> arg0 bot-flags)))
+          (set! (-> arg0 notice-enemy-dist) 122880.0)
+          (let ((v1-6 (get-task-by-type (-> arg0 ai-ctrl) kidt-wait-spot arg0)))
+            (set! (-> v1-6 bytes 5) (the-as uint 1))
+            (set! (-> v1-6 bytes 6) (the-as uint 2))
+            (set! (-> v1-6 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kidt-wait-spot v1-6) check-done)
+                  (the-as
+                    (function kidt-wait-spot kid symbol)
+                    (lambda ((arg0 object) (arg1 kid))
+                      (when (outside-spot-radius? arg1 (the-as bot-spot #f) (the-as vector #f) #f)
+                        (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                        (go-to-waypoint! arg1 6 #f)
+                        (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                        #t
+                        )
+                      )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update (lambda ((arg0 kid)) (kid-update-during-battle arg0) (none))
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 6
+        :skip-to -1
+        :on-set (lambda ((arg0 kid))
+          (let ((v1-1 (get-task-by-type (-> arg0 ai-ctrl) kidt-wait-spot arg0)))
+            (set! (-> v1-1 bytes 5) (the-as uint 1))
+            (set! (-> v1-1 bytes 6) (the-as uint 3))
+            (set! (-> v1-1 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kidt-wait-spot v1-1) check-done)
+                  (the-as
+                    (function kidt-wait-spot kid symbol)
+                    (lambda ((arg0 object) (arg1 kid)) (when (>= (-> arg1 waypoint-request) 8)
+                                                         (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                                                         (go-to-waypoint! arg1 8 #f)
+                                                         (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                                                         #t
+                                                         )
+                            )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update (lambda ((arg0 kid)) (kid-update-during-battle arg0) (none))
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 8
+        :skip-to -1
+        :on-set (lambda ((arg0 kid))
+          (logclear! (-> arg0 focus-status) (focus-status disable arrestable))
+          (let ((v1-3 (get-task-by-type (-> arg0 ai-ctrl) kidt-wait-spot arg0)))
+            (set! (-> v1-3 bytes 5) (the-as uint 1))
+            (set! (-> v1-3 bytes 6) (the-as uint 3))
+            (set! (-> v1-3 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kidt-wait-spot v1-3) check-done)
+                  (the-as
+                    (function kidt-wait-spot kid symbol)
+                    (lambda ((arg0 object) (arg1 kid)) (when (>= (-> arg1 waypoint-request) 10)
+                                                         (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                                                         (go-to-waypoint! arg1 10 #f)
+                                                         (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                                                         #t
+                                                         )
+                            )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update #f
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 10
+        :skip-to -1
+        :on-set (lambda ((arg0 kid))
+          (process-entity-status! arg0 (entity-perm-status bit-4) #f)
+          (send-event arg0 'die-fast)
+          (let ((v1-4 (get-task-by-type (-> arg0 ai-ctrl) kidt-wait-spot arg0)))
+            (set! (-> v1-4 bytes 5) (the-as uint 1))
+            (set! (-> v1-4 bytes 6) (the-as uint 3))
+            (set! (-> v1-4 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kidt-wait-spot v1-4) check-done)
+                  (the-as (function kidt-wait-spot kid symbol) (lambda () #f))
+                  )
+            )
+          (none)
+          )
+        :on-update #f
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      )
+    :spots (new 'static 'inline-array bot-spot 4
+      (new 'static 'bot-spot :center (new 'static 'vector :x 2600755.2 :y 32768.0 :z -375808.0 :w 10240.0))
+      (new 'static 'bot-spot :center (new 'static 'vector :x 2616828.0 :y 32768.0 :z -382325.56 :w -357075.75))
+      (new 'static 'bot-spot :center (new 'static 'vector :x 2575360.0 :y 32727.04 :z -191078.4 :w 32768.0))
+      (new 'static 'bot-spot :center (new 'static 'vector :x 2547753.0 :y 32727.04 :z -159252.48 :w 8192.0))
+      )
+    )
+  )
+
+(set! (-> *bot-course-table* course 7) *kid3-course*)
diff --git a/goal_src/jak2/levels/city/slums/kor/kor-h.gc b/goal_src/jak2/levels/city/slums/kor/kor-h.gc
index a1aad6016d..66bf6ea839 100644
--- a/goal_src/jak2/levels/city/slums/kor/kor-h.gc
+++ b/goal_src/jak2/levels/city/slums/kor/kor-h.gc
@@ -7,3 +7,44 @@
 
 ;; DECOMP BEGINS
 
+(deftype kor (bot)
+  ((travel-anim-interp  float       :offset-assert 992)
+   (arrest-attempt-time time-frame  :offset-assert 1000)
+   (arrestor-handle     handle      :offset-assert 1008)
+   )
+  :heap-base #x380
+  :method-count-assert 235
+  :size-assert         #x3f8
+  :flag-assert         #xeb038003f8
+  (:methods
+    (traveling () _type_ :state 225)
+    (traveling-blocked () _type_ :state 226)
+    (waiting-with-kid () _type_ :state 227)
+    (waiting-idle () _type_ :state 228)
+    (waiting-turn () _type_ :state 229)
+    (scared-idle () _type_ :state 230)
+    (arrested () _type_ :state 231)
+    (kor-method-232 (_type_) none 232)
+    (kor-method-233 (_type_) none 233)
+    (kor-method-234 (_type_) none 234)
+    )
+  )
+
+
+(defskelgroup skel-kor kor 0 3
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 0 0 2.5)
+              :shadow 2
+              :origin-joint-index 13
+              )
+
+(deftype kort-wait-spot (ai-task)
+  ((check-done   (function kort-wait-spot kor symbol)   :offset  32)
+   (which-spot   int8                                   :offset  36)
+   (num-spots    uint8                                  :offset  37)
+   (spot-indexes uint8                                6 :offset  38)
+   )
+  :method-count-assert 12
+  :size-assert         #x30
+  :flag-assert         #xc00000030
+  )
diff --git a/goal_src/jak2/levels/city/slums/kor/kor-states.gc b/goal_src/jak2/levels/city/slums/kor/kor-states.gc
index 98fca16b1a..73efe29940 100644
--- a/goal_src/jak2/levels/city/slums/kor/kor-states.gc
+++ b/goal_src/jak2/levels/city/slums/kor/kor-states.gc
@@ -7,3 +7,668 @@
 
 ;; DECOMP BEGINS
 
+(defstate waiting-idle (kor)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kor) 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
+    (nav-enemy-method-167 self)
+    (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))
+    (enemy-method-109 self 1)
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (b!
+      (not (and (-> self focus-info fproc) (>= (fabs (-> self focus-info ry-diff)) 9102.223)))
+      cfg-6
+      :delay (empty-form)
+      )
+    (kor-method-233 self)
+    (b! #t cfg-15 :delay (nop!))
+    (label cfg-6)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (if (if (type? gp-0 process-focusable)
+              gp-0
+              )
+          (go-virtual arrested)
+          )
+      )
+    (label cfg-15)
+    (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+      (if (not (outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #f))
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((v1-2 (ja-group)))
+      (cond
+        ((and v1-2 (= v1-2 (-> self draw art-group data 3)))
+         (ja-no-eval :num! (seek!))
+         (while (not (ja-done? 0))
+           (suspend)
+           (ja-eval)
+           )
+         )
+        (else
+          (ja-channel-push! 1 (seconds 0.2))
+          )
+        )
+      )
+    (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 (the-as (function none :behavior kor) nav-enemy-simple-post)
+  )
+
+(defstate waiting-turn (kor)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kor) 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
+    (nav-enemy-method-167 self)
+    (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))
+    (enemy-method-109 self 1)
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+      (if (and (not (outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #f))
+               (let ((gp-0 (handle->process (-> self arrestor-handle))))
+                 (not (if (type? gp-0 process-focusable)
+                          gp-0
+                          )
+                      )
+                 )
+               )
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (local-vars (s4-1 art-element) (f0-9 float))
+    (let ((gp-0 (new 'stack-no-clear 'bot-turn-info)))
+      (let ((s5-0 (-> self focus-info fproc)))
+        (if (not s5-0)
+            (kor-method-232 self)
+            )
+        (turn-to-target self gp-0 s5-0 1.867)
+        )
+      (let ((s4-0 (>= (-> gp-0 predicted-ry-diff) 0.0)))
+        (let ((s5-1 (-> self draw art-group data (if s4-0
+                                                     7
+                                                     11
+                                                     )
+                        )
+                    )
+              )
+          (ja-channel-push! 1 (seconds 0.2))
+          (ja-no-eval :group! s5-1
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim s5-1) frames num-frames) -1)))
+                      :frame-num 0.0
+                      )
+          )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek!))
+          )
+        (let ((a2-3 (-> self focus-info fproc)))
+          (if a2-3
+              (turn-to-target self gp-0 a2-3 1.6)
+              )
+          )
+        (let ((s5-2 (new 'stack-no-clear 'quaternion))
+              (f0-8 (-> gp-0 predicted-ry-diff))
+              (f30-0 4.0)
+              (f28-0 5.0)
+              )
+          (set! f28-0 (cond
+                        (s4-0
+                          (if (< f0-8 0.0)
+                              (set! f0-8 (+ 65536.0 f0-8))
+                              )
+                          (cond
+                            ((< f0-8 18204.445)
+                             (set! f0-9 9102.223)
+                             (set! s4-1 (-> self draw art-group data 8))
+                             (set! f30-0 5.0)
+                             14.0
+                             )
+                            ((< f0-8 27306.666)
+                             (set! f0-9 18204.445)
+                             (set! s4-1 (-> self draw art-group data 9))
+                             (set! f30-0 5.0)
+                             23.0
+                             )
+                            (else
+                              (set! f0-9 27306.666)
+                              (set! s4-1 (-> self draw art-group data 10))
+                              (set! f30-0 5.0)
+                              23.0
+                              )
+                            )
+                          )
+                        (else
+                          (if (>= f0-8 0.0)
+                              (set! f0-8 (+ -65536.0 f0-8))
+                              )
+                          (cond
+                            ((< -18204.445 f0-8)
+                             (set! f0-9 -9102.223)
+                             (set! s4-1 (-> self draw art-group data 12))
+                             )
+                            ((< -27306.666 f0-8)
+                             (set! f0-9 -18204.445)
+                             (set! s4-1 (-> self draw art-group data 13))
+                             (set! f30-0 5.0)
+                             (set! f28-0 23.0)
+                             )
+                            (else
+                              (set! f0-9 -27306.666)
+                              (set! s4-1 (-> self draw art-group data 14))
+                              (set! f30-0 5.0)
+                              (set! f28-0 23.0)
+                              )
+                            )
+                          f28-0
+                          )
+                        )
+                )
+          (quaternion-rotate-y! s5-2 (-> gp-0 src-quat) f0-9)
+          (ja-no-eval :group! s4-1
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim s4-1) frames num-frames) -1)))
+                      :frame-num 0.0
+                      )
+          (until (ja-done? 0)
+            (let ((f0-14 (ja-aframe-num 0)))
+              (cond
+                ((< f0-14 f28-0)
+                 (if (>= f0-14 f30-0)
+                     (quaternion-slerp! (-> self root-override2 quat) (-> gp-0 src-quat) s5-2 (/ (- f0-14 f30-0) (- f28-0 f30-0)))
+                     )
+                 )
+                (else
+                  (quaternion-copy! (-> self root-override2 quat) s5-2)
+                  )
+                )
+              )
+            (suspend)
+            (ja :num! (seek!))
+            )
+          )
+        )
+      )
+    (kor-method-232 self)
+    (none)
+    )
+  :post (the-as (function none :behavior kor) nav-enemy-simple-post)
+  )
+
+(defstate waiting-with-kid (kor)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kor) enemy-event-handler)
+  :enter (-> (method-of-type kor waiting-idle) enter)
+  :exit (-> (method-of-type kor waiting-idle) exit)
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+      (if (not (outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #f))
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (-> (method-of-type kor waiting-idle) code)
+  :post (-> (method-of-type kor waiting-idle) post)
+  )
+
+(defstate scared-idle (kor)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kor) 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
+    (nav-enemy-method-167 self)
+    (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))
+    (enemy-method-109 self 1)
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (b!
+      (not (and (-> self focus-info fproc) (>= (fabs (-> self focus-info ry-diff)) 9102.223)))
+      cfg-6
+      :delay (empty-form)
+      )
+    (kor-method-233 self)
+    (b! #t cfg-15 :delay (nop!))
+    (label cfg-6)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (if (if (type? gp-0 process-focusable)
+              gp-0
+              )
+          (go-virtual arrested)
+          )
+      )
+    (label cfg-15)
+    (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+      (if (not (outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #f))
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((v1-2 (ja-group)))
+      (cond
+        ((and v1-2 (= v1-2 (-> self draw art-group data 4)))
+         (ja-no-eval :num! (seek!))
+         (while (not (ja-done? 0))
+           (suspend)
+           (ja-eval)
+           )
+         )
+        (else
+          (ja-channel-push! 1 (seconds 0.2))
+          )
+        )
+      )
+    (until #f
+      (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!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior kor) nav-enemy-simple-post)
+  )
+
+(defstate traveling (kor)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kor) enemy-event-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (let ((v1-2 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-2 enemy-flags)))
+          (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-2 enemy-flags))))
+          )
+      (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-2 enemy-flags))))
+      (set! (-> v1-2 nav callback-info) (-> v1-2 enemy-info-override callback-info))
+      )
+    0
+    (let ((v1-5 self))
+      (set! (-> v1-5 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-5 enemy-flags))))
+      )
+    0
+    (enemy-method-110 self)
+    (nav-enemy-method-166 self)
+    (set! (-> self player-blocking) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (cond
+        ((if (type? gp-0 process-focusable)
+             gp-0
+             )
+         (go-virtual arrested)
+         )
+        ((outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #t)
+         (kor-method-232 self)
+         )
+        ((and (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.5)) (bot-method-208 self))
+         (go-virtual traveling-blocked)
+         )
+        ((and (nav-enemy-method-163 self)
+              (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+              )
+         (go-stare2 self)
+         )
+        )
+      )
+    0
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (kor-method-234 self)
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (let ((a0-0 (-> self nav state))
+          (v1-1 (-> self spot))
+          )
+      (logclear! (-> a0-0 flags) (nav-state-flag directional-mode))
+      (logior! (-> a0-0 flags) (nav-state-flag target-poly-dirty))
+      (set! (-> a0-0 target-post quad) (-> v1-1 center quad))
+      )
+    0
+    (nav-enemy-travel-post)
+    (none)
+    )
+  )
+
+(defstate traveling-blocked (kor)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kor) 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
+    (nav-enemy-method-167 self)
+    (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))
+    (enemy-method-109 self 1)
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (cond
+        ((if (type? gp-0 process-focusable)
+             gp-0
+             )
+         (go-virtual arrested)
+         )
+        ((and (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1)) (not (bot-method-208 self)))
+         (go-virtual traveling)
+         )
+        )
+      )
+    (none)
+    )
+  :code (-> (method-of-type kor waiting-idle) code)
+  :post (the-as (function none :behavior kor) nav-enemy-simple-post)
+  )
+
+(defstate stare (kor)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type bot stare) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (let ((v1-4 self))
+      (set! (-> v1-4 enemy-flags) (the-as enemy-flag (logclear (-> v1-4 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (if (if (type? gp-0 process-focusable)
+              gp-0
+              )
+          (go-virtual arrested)
+          )
+      )
+    (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1))
+      (if (not (nav-enemy-method-163 self))
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (-> (method-of-type kor waiting-idle) code)
+  )
+
+(defstate hit (kor)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type bot hit) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :code (behavior ()
+    (local-vars (v1-31 enemy-flag) (v1-39 enemy-flag))
+    (ja-channel-push! 1 (seconds 0.1))
+    (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!))
+      )
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (let ((v1-30 (-> self enemy-flags)))
+      (if (logtest? v1-30 (enemy-flag checking-water))
+          (set! v1-31 (logior v1-30 (enemy-flag enable-on-active)))
+          (set! v1-31 (logclear v1-30 (enemy-flag enable-on-active)))
+          )
+      )
+    (set! (-> self enemy-flags) v1-31)
+    (if (logtest? (-> self enemy-flags) (enemy-flag look-at-move-dest))
+        (set! (-> self mask) (logior (process-mask collectable) (-> self mask)))
+        (logclear! (-> self mask) (process-mask collectable))
+        )
+    (let ((v1-38 (-> self enemy-flags)))
+      (if (logtest? (enemy-flag no-initial-move-to-ground) v1-38)
+          (set! v1-39 (logior (enemy-flag check-water-backup) v1-38))
+          (set! v1-39 (logclear v1-38 (enemy-flag check-water-backup)))
+          )
+      )
+    (set! (-> self enemy-flags) v1-39)
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (logclear! (-> self focus-status) (focus-status hit))
+    (enemy-method-72 self)
+    (none)
+    )
+  )
+
+(defstate knocked (kor)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type bot knocked) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  )
+
+(defstate arrested (kor)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kor) 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
+    (nav-enemy-method-167 self)
+    (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))
+    (enemy-method-110 self)
+    (set! (-> self travel-anim-interp) 0.0)
+    (if (logtest? (bot-flags bf20) (-> self bot-flags))
+        (logclear! (-> self enemy-flags) (enemy-flag enable-on-active checking-water))
+        )
+    (none)
+    )
+  :trans (behavior ()
+    (cond
+      ((logtest? (-> self bot-flags) (bot-flags bf09))
+       (fail-falling self)
+       )
+      (else
+        (bot-method-223 self #f)
+        (when (not (logtest? (bot-flags bf20) (-> self bot-flags)))
+          (if (and (-> self focus-info fproc) (>= (fabs (-> self focus-info ry-diff)) 9102.223))
+              (kor-method-233 self)
+              )
+          (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+            (let ((gp-0 (handle->process (-> self arrestor-handle))))
+              (if (not (if (type? gp-0 process-focusable)
+                           gp-0
+                           )
+                       )
+                  (enemy-method-72 self)
+                  )
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.25))
+    (cond
+      ((and (not (logtest? (bot-flags bf20) (-> self bot-flags)))
+            (< (- (-> self clock frame-counter) (-> self arrest-attempt-time)) (seconds 0.8))
+            )
+       (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!))
+         )
+       )
+      (else
+        (ja-no-eval :group! (-> self draw art-group data 4) :num! (seek! (ja-aframe 8.0 0)) :frame-num 0.0)
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek! (ja-aframe 8.0 0)))
+          )
+        )
+      )
+    (fail-mission! self)
+    (let* ((gp-2 (handle->process (-> self arrestor-handle)))
+           (v1-49 (if (type? gp-2 process-focusable)
+                      gp-2
+                      )
+                  )
+           )
+      (if v1-49
+          (logclear! (-> (the-as crimson-guard v1-49) enemy-flags) (enemy-flag enable-on-active checking-water))
+          )
+      )
+    (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 (ja-aframe 4.0 0)
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (until #f
+      (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)
+        (if (and (logtest? (-> self bot-flags) (bot-flags failed))
+                 (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 3))
+                 (reset? *fail-mission-control*)
+                 )
+            (reset! *fail-mission-control*)
+            )
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior kor) nav-enemy-simple-post)
+  )
+
+(defstate failed (kor)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self bot-flags) (logior (bot-flags bf20) (-> self bot-flags)))
+    ((-> (method-of-type kor arrested) enter))
+    (none)
+    )
+  :trans (-> (method-of-type kor arrested) trans)
+  :code (-> (method-of-type kor arrested) code)
+  :post (-> (method-of-type kor arrested) post)
+  )
+
+(defstate die-falling (kor)
+  :virtual #t
+  :enter (-> (method-of-type kor failed) enter)
+  :trans (-> (method-of-type kor failed) trans)
+  :code (-> (method-of-type kor failed) code)
+  )
diff --git a/goal_src/jak2/levels/city/slums/kor/kor-task.gc b/goal_src/jak2/levels/city/slums/kor/kor-task.gc
index bae5d176a3..aa7ae5987a 100644
--- a/goal_src/jak2/levels/city/slums/kor/kor-task.gc
+++ b/goal_src/jak2/levels/city/slums/kor/kor-task.gc
@@ -7,3 +7,44 @@
 
 ;; DECOMP BEGINS
 
+(defmethod reset-task! kort-wait-spot ((obj kort-wait-spot))
+  "Virtual"
+  (set! (-> obj check-done) #f)
+  (set! (-> obj which-spot) -1)
+  (set! (-> obj num-spots) (the-as uint 0))
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch symbol vs none.
+(defmethod ai-task-method-11 kort-wait-spot ((obj kort-wait-spot) (arg0 bot))
+  "Virtual"
+  (let ((s4-0 (-> obj which-spot)))
+    (when (>= s4-0 0)
+      (let ((s3-0 (-> arg0 course spots (-> obj spot-indexes s4-0))))
+        (if (and (not (outside-spot-radius? arg0 s3-0 (the-as vector #f) #f)) (player-blocking-spot? arg0 s3-0))
+            (set! s4-0 -1)
+            )
+        )
+      )
+    (when (< s4-0 0)
+      (set! s4-0 (choose-spot arg0 (the-as int (-> obj num-spots)) (the-as (pointer uint) (-> obj spot-indexes))))
+      (set! (-> obj which-spot) s4-0)
+      (mem-copy!
+        (the-as pointer (-> arg0 spot))
+        (the-as pointer (-> arg0 course spots (-> obj spot-indexes s4-0)))
+        20
+        )
+      )
+    (if (logtest? *display-bot-marks* (bot-marks-controls bmc16))
+        (bot-debug-draw-spot-sphere
+          arg0
+          (the-as int (-> obj num-spots))
+          (the-as (pointer uint) (-> obj spot-indexes))
+          (the-as int (-> obj spot-indexes s4-0))
+          )
+        )
+    )
+  ((-> obj check-done) obj (the-as kor arg0))
+  (none)
+  )
diff --git a/goal_src/jak2/levels/city/slums/kor/kor.gc b/goal_src/jak2/levels/city/slums/kor/kor.gc
index c376270f46..3a0f2f4474 100644
--- a/goal_src/jak2/levels/city/slums/kor/kor.gc
+++ b/goal_src/jak2/levels/city/slums/kor/kor.gc
@@ -7,3 +7,578 @@
 
 ;; DECOMP BEGINS
 
+(deftype kor-anim-info (structure)
+  ((anim-index int32  :offset-assert   0)
+   )
+  :method-count-assert 9
+  :size-assert         #x4
+  :flag-assert         #x900000004
+  )
+
+
+(define *kor-nav-enemy-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 idle-control-frame 2
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x3 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 3
+    :notice-anim 3
+    :hostile-anim -1
+    :hit-anim 3
+    :knocked-anim 15
+    :knocked-land-anim 16
+    :die-anim 3
+    :die-falling-anim 3
+    :victory-anim -1
+    :jump-wind-up-anim 3
+    :jump-in-air-anim 3
+    :jump-land-anim 3
+    :neck-joint 6
+    :look-at-joint 6
+    :bullseye-joint 4
+    :notice-distance (meters 30)
+    :notice-distance-delta (meters 10)
+    :proximity-notice-distance (meters 30)
+    :default-hit-points 100
+    :gnd-collide-with (collide-spec backgnd)
+    :overlaps-others-collide-with-filter (collide-spec jak civilian enemy vehicle-sphere hit-by-others-list player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.7
+    :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 2730.6667
+    :knocked-soft-vxz-lo 43008.0
+    :knocked-soft-vxz-hi 43008.0
+    :knocked-soft-vy-lo 79872.0
+    :knocked-soft-vy-hi 79872.0
+    :knocked-medium-vxz-lo 43008.0
+    :knocked-medium-vxz-hi 43008.0
+    :knocked-medium-vy-lo 79872.0
+    :knocked-medium-vy-hi 79872.0
+    :knocked-hard-vxz-lo 43008.0
+    :knocked-hard-vxz-hi 43008.0
+    :knocked-hard-vy-lo 79872.0
+    :knocked-hard-vy-hi 79872.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 43008.0
+    :knocked-yellow-vxz-hi 43008.0
+    :knocked-yellow-vy-lo 79872.0
+    :knocked-yellow-vy-hi 79872.0
+    :knocked-red-vxz-lo 43008.0
+    :knocked-red-vxz-hi 43008.0
+    :knocked-red-vy-lo 79872.0
+    :knocked-red-vy-hi 79872.0
+    :knocked-blue-vxz-lo 43008.0
+    :knocked-blue-vxz-hi 43008.0
+    :knocked-blue-vy-lo 79872.0
+    :knocked-blue-vy-hi 79872.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 #t
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #f
+    :use-pacing #f
+    :walk-anim 3
+    :turn-anim -1
+    :run-anim 3
+    :taunt-anim -1
+    :run-travel-speed (meters 5.1)
+    :run-acceleration (meters 5)
+    :run-turning-acceleration (meters 6)
+    :walk-travel-speed (meters 1.5)
+    :walk-acceleration (meters 5)
+    :walk-turning-acceleration (meters 6)
+    :maximum-rotation-rate (degrees 180.0)
+    :notice-nav-radius (meters 1)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 20480.0
+    :circle-dist-hi 61440.0
+    :nav-mesh #f
+    )
+  )
+
+(set! (-> *kor-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+(defmethod enemy-method-74 kor ((obj kor) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (with-pp
+    (case arg2
+      (('arrest)
+       (let* ((s4-0 (handle->process (-> obj arrestor-handle)))
+              (v1-4 (if (type? s4-0 process-focusable)
+                        s4-0
+                        )
+                    )
+              )
+         (when (or (not v1-4)
+                   (= v1-4 arg0)
+                   (and (!= v1-4 arg0) (>= (- (-> pp clock frame-counter) (-> obj arrest-attempt-time)) (seconds 0.1)))
+                   )
+           (set! (-> obj arrestor-handle) (process->handle arg0))
+           (set! (-> obj arrest-attempt-time) (-> pp clock frame-counter))
+           0
+           )
+         )
+       #t
+       )
+      (('instant-arrest)
+       (set! (-> obj bot-flags) (logior (bot-flags bf20) (-> obj bot-flags)))
+       (let ((v1-18 (the-as object (-> arg3 param 0))))
+         (set! (-> obj arrestor-handle) (process->handle (the-as process v1-18)))
+         (set! (-> obj arrest-attempt-time) (-> pp clock frame-counter))
+         (let ((a1-8 (new 'stack-no-clear 'vector)))
+           (vector-! a1-8 (-> (the-as process-drawable v1-18) root trans) (-> obj root-override2 trans))
+           (set! (-> a1-8 y) 0.0)
+           (forward-up->quaternion (-> obj root-override2 quat) a1-8 *up-vector*)
+           )
+         )
+       (logclear! (-> obj enemy-flags) (enemy-flag enable-on-active checking-water))
+       (logclear! (-> obj mask) (process-mask collectable))
+       (logclear! (-> obj enemy-flags) (enemy-flag look-at-move-dest))
+       (logclear! (-> obj mask) (process-mask actor-pause))
+       (logclear! (-> obj enemy-flags) (enemy-flag notice))
+       (go (method-of-object obj arrested))
+       )
+      (else
+        ((method-of-type bot enemy-method-74) obj arg0 arg1 arg2 arg3)
+        )
+      )
+    )
+  )
+
+(defmethod enemy-method-97 kor ((obj kor))
+  (with-pp
+    (let* ((s4-0 (handle->process (-> obj attacker-handle)))
+           (s5-0 (if (type? s4-0 process-focusable)
+                     s4-0
+                     )
+                 )
+           (s3-0 (handle->process (-> obj arrestor-handle)))
+           (s4-1 (if (type? s3-0 process-focusable)
+                     s3-0
+                     )
+                 )
+           )
+      (when s5-0
+        (cond
+          ((= (-> s5-0 type) target)
+           (when (or (not (logtest? (-> obj bot-flags) (bot-flags attacked)))
+                     (>= (- (-> pp clock frame-counter) (-> obj attacker-time)) (seconds 1.5))
+                     )
+             (if (logtest? (-> obj bot-flags) (bot-flags attacked))
+                 (reset-attacker! obj)
+                 )
+             (set! s5-0 (the-as process #f))
+             (set! (-> obj attacker-handle) (the-as handle #f))
+             )
+           )
+          (else
+            (when (>= (- (-> pp clock frame-counter) (-> obj attacker-time)) (seconds 6))
+              (set! s5-0 (the-as process #f))
+              (set! (-> obj attacker-handle) (the-as handle #f))
+              )
+            )
+          )
+        )
+      (when s4-1
+        (when (or (>= (- (-> pp clock frame-counter) (-> obj arrest-attempt-time)) (seconds 0.5))
+                  (logtest? (-> (the-as process-focusable s4-1) focus-status) (focus-status dead hit))
+                  )
+          (set! s4-1 (the-as process #f))
+          (set! (-> obj arrestor-handle) (the-as handle #f))
+          )
+        )
+      (let ((v1-34 (-> obj focus-mode))
+            (s3-1 (the-as process #f))
+            )
+        (cond
+          ((zero? v1-34)
+           (cond
+             (s4-1
+               (set! s3-1 s4-1)
+               )
+             (s5-0
+               (set! s3-1 s5-0)
+               )
+             ((begin (set! s3-1 (select-focus! obj)) s3-1)
+              (empty)
+              )
+             (else
+               (let ((s5-1 (handle->process (-> obj poi-handle))))
+                 (set! s3-1 (if (type? s5-1 process-focusable)
+                                s5-1
+                                )
+                       )
+                 )
+               (if s3-1
+                   (empty)
+                   (set! s3-1 *target*)
+                   )
+               )
+             )
+           )
+          ((= v1-34 1)
+           (cond
+             (s4-1
+               (set! s3-1 s4-1)
+               )
+             (s5-0
+               (set! s3-1 s5-0)
+               )
+             (else
+               (let ((s5-2 (handle->process (-> obj poi-handle))))
+                 (set! s3-1 (if (type? s5-2 process-focusable)
+                                s5-2
+                                )
+                       )
+                 )
+               (cond
+                 (s3-1
+                   (empty)
+                   )
+                 ((begin (set! s3-1 (select-focus! obj)) s3-1)
+                  (empty)
+                  )
+                 (else
+                   (set! s3-1 *target*)
+                   )
+                 )
+               )
+             )
+           )
+          )
+        (cond
+          (s3-1
+            (try-update-focus (-> obj focus) (the-as process-focusable s3-1) obj)
+            (if (and (logtest? (-> obj bot-flags) (bot-flags attacked)) (!= (-> s3-1 type) target))
+                (logclear! (-> obj bot-flags) (bot-flags attacked))
+                )
+            )
+          (else
+            (clear-focused (-> obj focus))
+            (logclear! (-> obj bot-flags) (bot-flags attacked))
+            )
+          )
+        s3-1
+        )
+      )
+    )
+  )
+
+(defmethod alive? kor ((obj kor))
+  (let ((t9-0 (method-of-type bot alive?)))
+    (and (t9-0 obj)
+         (not (and (-> obj next-state) (let ((v1-4 (-> obj next-state name)))
+                                         (or (= v1-4 'arrested) (= v1-4 'die) (= v1-4 'die-falling))
+                                         )
+                   )
+              )
+         (zero? (logand (bot-flags bf20) (-> obj bot-flags)))
+         )
+    )
+  )
+
+(defmethod enemy-method-114 kor ((obj kor))
+  "@abstract"
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum hit-by-others))))
+    (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 3) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 4))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec bot bot-targetable))
+      (set! (-> s4-0 prim-core collide-with)
+            (collide-spec backgnd jak crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
+            )
+      (set! (-> s4-0 prim-core action) (collide-action solid can-ride no-standon))
+      (set-vector! (-> s4-0 local-sphere) 0.0 4505.6 0.0 7372.8)
+      (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 bot bot-targetable))
+      (set! (-> v1-13 prim-core collide-with)
+            (collide-spec backgnd jak crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-13 prim-core action) (collide-action solid can-ride))
+      (set-vector! (-> v1-13 local-sphere) 0.0 2867.2 0.0 2867.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 bot bot-targetable))
+      (set! (-> v1-15 prim-core collide-with)
+            (collide-spec backgnd jak crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-15 prim-core action) (collide-action solid))
+      (set-vector! (-> v1-15 local-sphere) 0.0 5529.6 0.0 2867.2)
+      )
+    (let ((v1-17 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-17 prim-core collide-as) (collide-spec bot bot-targetable))
+      (set! (-> v1-17 prim-core collide-with)
+            (collide-spec backgnd jak crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-17 prim-core action) (collide-action solid no-standon))
+      (set-vector! (-> v1-17 local-sphere) 0.0 8192.0 0.0 2867.2)
+      )
+    (set! (-> s5-0 nav-radius) 4096.0)
+    (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! (-> s5-0 max-iteration-count) (the-as uint 3))
+    (set! (-> s5-0 event-priority) (the-as uint 2))
+    (set! (-> obj root-override2) s5-0)
+    )
+  0
+  (none)
+  )
+
+(defmethod init! kor ((obj kor))
+  "Set defaults for various fields."
+  (let ((t9-0 (method-of-type bot init!)))
+    (t9-0 obj)
+    )
+  (set! (-> obj min-speed) 6144.0)
+  (set! (-> obj max-speed) 20889.6)
+  (set! (-> obj channel) (the-as uint 27))
+  (set! (-> obj notice-enemy-dist) 122880.0)
+  (set! (-> obj travel-anim-interp) 0.0)
+  (set! (-> obj focus-info max-los-dist) 0.0)
+  (set-vector! (-> obj root-override2 scale) 1.2 1.2 1.2 1.0)
+  (set! (-> obj spot-color) (the-as uint #x508f2f00))
+  (set! (-> obj arrestor-handle) (the-as handle #f))
+  0
+  (none)
+  )
+
+(defmethod enemy-method-115 kor ((obj kor))
+  "@abstract"
+  (init! obj)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-kor" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (enemy-method-113 obj *kor-nav-enemy-info*)
+  (let ((v1-7 (-> obj neck)))
+    (set! (-> v1-7 up) (the-as uint 1))
+    (set! (-> v1-7 nose) (the-as uint 2))
+    (set! (-> v1-7 ear) (the-as uint 0))
+    (set-vector! (-> v1-7 twist-max) 11832.889 11832.889 0.0 1.0)
+    (set! (-> v1-7 ignore-angle) 30947.555)
+    )
+  (let ((t9-4 (method-of-type bot enemy-method-115)))
+    (t9-4 obj)
+    )
+  (set! (-> obj my-simple-focus) (process-spawn simple-focus :to obj))
+  0
+  (none)
+  )
+
+(defmethod bot-method-214 kor ((obj kor))
+  #f
+  )
+
+(defmethod go-hostile kor ((obj kor))
+  (kor-method-232 obj)
+  (none)
+  )
+
+(defmethod enemy-method-72 kor ((obj kor))
+  (kor-method-232 obj)
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod kor-method-233 kor ((obj kor))
+  (go (method-of-object obj waiting-turn))
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod kor-method-232 kor ((obj kor))
+  (let ((s5-0 (handle->process (-> obj arrestor-handle))))
+    (cond
+      ((if (type? s5-0 process-focusable)
+           s5-0
+           )
+       (go (method-of-object obj arrested))
+       )
+      ((logtest? (bot-flags bf19) (-> obj bot-flags))
+       (go (method-of-object obj scared-idle))
+       )
+      (else
+        (go (method-of-object obj waiting-idle))
+        )
+      )
+    )
+  (none)
+  )
+
+(defmethod kor-method-234 kor ((obj kor))
+  (with-pp
+    (let ((f30-0 (-> obj nav state speed)))
+      (let ((f0-1 (lerp-scale 0.0 1.0 f30-0 6144.0 20889.6)))
+        (seek! (-> obj travel-anim-interp) f0-1 (* 4.0 (-> pp clock seconds-per-frame)))
+        )
+      (let ((f28-0 (-> obj travel-anim-interp))
+            (v1-7 (if (> (-> obj skel active-channels) 0)
+                      (-> obj skel root-channel 0 frame-group)
+                      )
+                  )
+            )
+        (cond
+          ((and v1-7 (= v1-7 (-> obj draw art-group data 5)))
+           (let ((v1-12 (-> obj skel root-channel 1)))
+             (set! (-> v1-12 frame-interp 1) f28-0)
+             (set! (-> v1-12 frame-interp 0) f28-0)
+             )
+           (let* ((f28-1 (current-cycle-distance (-> obj skel)))
+                  (f0-5 (quaternion-y-angle (-> obj root-override2 quat)))
+                  (f0-7 (deg- f0-5 (-> obj travel-prev-ry)))
+                  (f0-10 (fmin 20889.6 (* 0.35342914 (-> pp clock frames-per-second) (fabs f0-7))))
+                  (f0-13 (/ (* 24.0 (fmax f30-0 f0-10)) (* 15.0 f28-1)))
+                  (a0-10 (-> obj skel root-channel 0))
+                  )
+             (set! (-> a0-10 param 0) f0-13)
+             (joint-control-channel-group-eval! a0-10 (the-as art-joint-anim #f) num-func-loop!)
+             )
+           (let ((a0-11 (-> obj skel root-channel 1)))
+             (set! (-> a0-11 param 0) 0.0)
+             (joint-control-channel-group-eval! a0-11 (the-as art-joint-anim #f) num-func-chan)
+             )
+           )
+          (else
+            (ja-channel-push! 2 (seconds 0.3))
+            (let ((a0-13 (-> obj skel root-channel 0)))
+              (set! (-> a0-13 dist) 9830.4)
+              (set! (-> a0-13 frame-group) (the-as art-joint-anim (-> obj draw art-group data 5)))
+              (set! (-> a0-13 param 0) 1.0)
+              (joint-control-channel-group! a0-13 (the-as art-joint-anim (-> obj draw art-group data 5)) num-func-loop!)
+              )
+            (let ((a0-14 (-> obj skel root-channel 1)))
+              (set! (-> a0-14 frame-interp 1) f28-0)
+              (set! (-> a0-14 frame-interp 0) f28-0)
+              (set! (-> a0-14 dist) 19660.8)
+              (set! (-> a0-14 frame-group) (the-as art-joint-anim (-> obj draw art-group data 6)))
+              (set! (-> a0-14 param 0) 0.0)
+              (joint-control-channel-group! a0-14 (the-as art-joint-anim (-> obj draw art-group data 6)) num-func-chan)
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  )
+
+(defmethod enemy-method-56 kor ((obj kor) (arg0 process) (arg1 event-message-block))
+  0
+  )
+
+(defmethod bot-method-190 kor ((obj kor))
+  #t
+  )
+
+(defmethod enemy-method-78 kor ((obj kor) (arg0 (pointer float)))
+  (ja-channel-push! 1 (seconds 0.1))
+  (let ((a1-2 (-> obj draw art-group data (-> obj enemy-info-override knocked-land-anim)))
+        (a0-4 (-> obj skel root-channel 0))
+        )
+    (set! (-> a0-4 frame-group) (the-as art-joint-anim a1-2))
+    (set! (-> a0-4 param 0) (the float (+ (-> (the-as art-joint-anim a1-2) 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-2) num-func-seek!)
+    )
+  #t
+  )
+
+;; WARN: Return type mismatch float vs meters.
+(defmethod set-cam-height! kor ((obj kor) (arg0 vector))
+  (the-as
+    meters
+    (cond
+      ((and (-> obj next-state) (= (-> obj next-state name) 'arrested))
+       (set-vector! arg0 49152.0 12288.0 49152.0 1.0)
+       (vector<-cspace+vector! arg0 (-> obj node-list data 2) arg0)
+       (if (logtest? (-> obj focus-status) (focus-status under-water))
+           (set! (-> arg0 y) (+ (get-water-height obj) (-> *setting-control* cam-current target-height)))
+           )
+       )
+      (else
+        ((method-of-type bot set-cam-height!) obj arg0)
+        )
+      )
+    )
+  )
+
+(defmethod enemy-method-102 kor ((obj kor))
+  (if (logtest? (bot-flags bf20) (-> obj bot-flags))
+      #f
+      ((method-of-type bot enemy-method-102) obj)
+      )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod go-idle kor ((obj kor))
+  (cond
+    ((= (-> obj course course-id) 8)
+     (cond
+       ((task-node-closed? (game-task-node city-help-kid-resolution))
+        (cleanup-for-death obj)
+        (go (method-of-object obj die-fast))
+        )
+       (else
+         (go (method-of-object obj waiting-with-kid))
+         )
+       )
+     )
+    (else
+      (go (method-of-object obj waiting-idle))
+      )
+    )
+  (none)
+  )
diff --git a/goal_src/jak2/levels/city/slums/kor/kor3-course.gc b/goal_src/jak2/levels/city/slums/kor/kor3-course.gc
index 32c1a397cf..0346a28a00 100644
--- a/goal_src/jak2/levels/city/slums/kor/kor3-course.gc
+++ b/goal_src/jak2/levels/city/slums/kor/kor3-course.gc
@@ -7,3 +7,229 @@
 
 ;; DECOMP BEGINS
 
+;; WARN: Return type mismatch focus-status vs none.
+(defun kor-update-during-battle ((arg0 kor))
+  (let ((v1-0 *target*))
+    (if (and v1-0 (-> v1-0 next-state) (let ((v1-3 (-> v1-0 next-state name)))
+                                         (or (= v1-3 'target-darkjak-get-on) (= v1-3 'target-darkjak-get-off))
+                                         )
+             )
+        (logior! (-> arg0 focus-status) (focus-status disable))
+        (logclear! (-> arg0 focus-status) (focus-status disable))
+        )
+    )
+  (none)
+  )
+
+(define *kor3-course*
+  (new 'static 'bot-course
+    :course-id #x8
+    :spot-count #x4
+    :default-check-too-far #f
+    :waypoints (new 'static 'boxed-array :type bot-waypoint
+      (new 'static 'bot-waypoint
+        :waypoint-id 1
+        :skip-to -1
+        :on-set (lambda ((arg0 kor))
+          (process-entity-status! arg0 (entity-perm-status no-kill) #t)
+          (clear-speech-flags! arg0)
+          (logior! (-> arg0 focus-status) (focus-status disable))
+          (set! (-> arg0 notice-enemy-dist) 0.0)
+          (let ((v1-5 (-> arg0 root-override2 root-prim)))
+            (set! (-> v1-5 prim-core collide-as) (collide-spec))
+            (set! (-> v1-5 prim-core collide-with) (collide-spec))
+            )
+          0
+          (move-to-point! (-> arg0 root-override2) (the-as vector (-> arg0 course spots 0)))
+          (logclear! (-> arg0 mask) (process-mask actor-pause))
+          (logclear! (-> arg0 enemy-flags) (enemy-flag notice))
+          (let ((v1-16 (get-task-by-type (-> arg0 ai-ctrl) kort-wait-spot arg0)))
+            (set! (-> v1-16 bytes 5) (the-as uint 1))
+            (set! (-> v1-16 bytes 6) (the-as uint 0))
+            (set! (-> v1-16 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kort-wait-spot v1-16) check-done)
+                  (the-as
+                    (function kort-wait-spot kor symbol)
+                    (lambda ((arg0 object) (arg1 kor)) (when (< 1 (-> arg1 waypoint-request))
+                                                         (let* ((v1-4 (-> arg1 actor-group 0 data 0 actor))
+                                                                (a0-2 (if v1-4
+                                                                          (-> v1-4 extra process)
+                                                                          )
+                                                                      )
+                                                                )
+                                                           (when a0-2
+                                                             (set! (-> arg1 master-handle) (process->handle a0-2))
+                                                             (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                                                             (go-to-waypoint! arg1 2 #f)
+                                                             (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                                                             #t
+                                                             )
+                                                           )
+                                                         )
+                            )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update #f
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 2
+        :skip-to -1
+        :on-set (lambda ((arg0 kor))
+          (let ((v1-1 (-> arg0 root-override2 root-prim)))
+            (set! (-> v1-1 prim-core collide-as) (-> arg0 root-override2 backup-collide-as))
+            (set! (-> v1-1 prim-core collide-with) (-> arg0 root-override2 backup-collide-with))
+            )
+          (logclear! (-> arg0 focus-status) (focus-status disable))
+          (let ((v1-5 (get-task-by-type (-> arg0 ai-ctrl) kort-wait-spot arg0)))
+            (set! (-> v1-5 bytes 5) (the-as uint 1))
+            (set! (-> v1-5 bytes 6) (the-as uint 0))
+            (set! (-> v1-5 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kort-wait-spot v1-5) check-done)
+                  (the-as
+                    (function kort-wait-spot kor symbol)
+                    (lambda ((arg0 object) (arg1 kor))
+                      (when (>= (-> arg1 waypoint-request) 6)
+                        (set! (-> arg1 root-override2 trans quad) (-> arg1 course spots 1 center quad))
+                        (set! (-> arg1 root-override2 trans w) 1.0)
+                        (quaternion-vector-angle!
+                          (-> arg1 root-override2 quat)
+                          *up-vector*
+                          (* 182.04445 (* 0.00024414062 (-> arg1 course spots 1 center w)))
+                          )
+                        (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                        (go-to-waypoint! arg1 5 #f)
+                        (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                        #t
+                        )
+                      )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update #f
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 5
+        :skip-to -1
+        :on-set (lambda ((arg0 kor))
+          (set! (-> arg0 focus-status) (logior (focus-status arrestable) (-> arg0 focus-status)))
+          (set! (-> arg0 bot-flags) (logior (bot-flags bf19) (-> arg0 bot-flags)))
+          (set! (-> arg0 notice-enemy-dist) 122880.0)
+          (let ((v1-6 (get-task-by-type (-> arg0 ai-ctrl) kort-wait-spot arg0)))
+            (set! (-> v1-6 bytes 5) (the-as uint 1))
+            (set! (-> v1-6 bytes 6) (the-as uint 2))
+            (set! (-> v1-6 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kort-wait-spot v1-6) check-done)
+                  (the-as
+                    (function kort-wait-spot kor symbol)
+                    (lambda ((arg0 object) (arg1 kor))
+                      (when (outside-spot-radius? arg1 (the-as bot-spot #f) (the-as vector #f) #f)
+                        (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                        (go-to-waypoint! arg1 6 #f)
+                        (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                        #t
+                        )
+                      )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update (lambda ((arg0 kor)) (kor-update-during-battle arg0) (none))
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 6
+        :skip-to -1
+        :on-set (lambda ((arg0 kor))
+          (let ((v1-1 (get-task-by-type (-> arg0 ai-ctrl) kort-wait-spot arg0)))
+            (set! (-> v1-1 bytes 5) (the-as uint 1))
+            (set! (-> v1-1 bytes 6) (the-as uint 3))
+            (set! (-> v1-1 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kort-wait-spot v1-1) check-done)
+                  (the-as
+                    (function kort-wait-spot kor symbol)
+                    (lambda ((arg0 object) (arg1 kor)) (when (>= (-> arg1 waypoint-request) 8)
+                                                         (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                                                         (go-to-waypoint! arg1 8 #f)
+                                                         (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                                                         #t
+                                                         )
+                            )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update (lambda ((arg0 kor)) (kor-update-during-battle arg0) (none))
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 8
+        :skip-to -1
+        :on-set (lambda ((arg0 kor))
+          (logclear! (-> arg0 focus-status) (focus-status disable arrestable))
+          (let ((v1-3 (get-task-by-type (-> arg0 ai-ctrl) kort-wait-spot arg0)))
+            (set! (-> v1-3 bytes 5) (the-as uint 1))
+            (set! (-> v1-3 bytes 6) (the-as uint 3))
+            (set! (-> v1-3 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kort-wait-spot v1-3) check-done)
+                  (the-as
+                    (function kort-wait-spot kor symbol)
+                    (lambda ((arg0 object) (arg1 kor)) (when (>= (-> arg1 waypoint-request) 10)
+                                                         (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                                                         (go-to-waypoint! arg1 10 #f)
+                                                         (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                                                         #t
+                                                         )
+                            )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update #f
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 10
+        :skip-to -1
+        :on-set (lambda ((arg0 kor))
+          (process-entity-status! arg0 (entity-perm-status bit-4) #f)
+          (send-event arg0 'die-fast)
+          (let ((v1-4 (get-task-by-type (-> arg0 ai-ctrl) kort-wait-spot arg0)))
+            (set! (-> v1-4 bytes 5) (the-as uint 1))
+            (set! (-> v1-4 bytes 6) (the-as uint 3))
+            (set! (-> v1-4 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kort-wait-spot v1-4) check-done)
+                  (the-as (function kort-wait-spot kor symbol) (lambda () #f))
+                  )
+            )
+          (none)
+          )
+        :on-update #f
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      )
+    :spots (new 'static 'inline-array bot-spot 4
+      (new 'static 'bot-spot :center (new 'static 'vector :x 2604400.8 :y 32604.16 :z -375070.72 :w 10240.0))
+      (new 'static 'bot-spot :center (new 'static 'vector :x 2618215.8 :y 32768.0 :z -391537.47 :w -504556.34))
+      (new 'static 'bot-spot :center (new 'static 'vector :x 2599608.2 :y 32727.04 :z -200253.44 :w 32768.0))
+      (new 'static 'bot-spot :center (new 'static 'vector :x 2546770.0 :y 32727.04 :z -177561.6 :w 8192.0))
+      )
+    )
+  )
+
+(set! (-> *bot-course-table* course 8) *kor3-course*)
diff --git a/goal_src/jak2/levels/common/enemy/spyder.gc b/goal_src/jak2/levels/common/enemy/spyder.gc
index 7c6548f352..b2607231fb 100644
--- a/goal_src/jak2/levels/common/enemy/spyder.gc
+++ b/goal_src/jak2/levels/common/enemy/spyder.gc
@@ -7,3 +7,1337 @@
 
 ;; DECOMP BEGINS
 
+(deftype spyder-shot (metalhead-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 spyder-shot ((obj spyder-shot) (arg0 projectile-options))
+  (let ((v1-0 arg0))
+    (cond
+      ((zero? v1-0)
+       (sound-play "spyder-fire")
+       )
+      ((= v1-0 (projectile-options lose-altitude))
+       (sound-play "spyder-shot-hit")
+       )
+      )
+    )
+  (the-as sound-id 0)
+  )
+
+(defmethod init-proj-settings! spyder-shot ((obj spyder-shot))
+  "Init relevant settings for the [[projectile]] such as gravity, speed, timeout, etc
+:virtual"
+  ((the-as (function projectile none) (find-parent-method spyder-shot 31)) obj)
+  (set! (-> obj max-speed) 307200.0)
+  (set! (-> obj timeout) (seconds 0.267))
+  (none)
+  )
+
+(defskelgroup skel-spyder spyder spyder-lod0-jg -1
+              ((spyder-lod0-mg (meters 20)) (spyder-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 5)
+              :shadow spyder-shadow-mg
+              :origin-joint-index 28
+              )
+
+(deftype spyder (nav-enemy)
+  ((los               los-control  :inline   :offset-assert 608)
+   (joint             joint-mod              :offset-assert 756)
+   (start-pos         vector       :inline   :offset-assert 768)
+   (face-pos          vector       :inline   :offset        800)
+   (my-up-vector      vector       :inline   :offset-assert 816)
+   (status-flags      uint64                 :offset-assert 832)
+   (change-dir-timer  time-frame             :offset-assert 840)
+   (fire-info         vector       2 :inline :offset-assert 848)
+   (joint-ik          joint-mod-ik 4         :offset        880)
+   (delta-y-ik        float        4         :offset-assert 896)
+   (predator-effect?  symbol                 :offset-assert 912)
+   (shock-effect-time time-frame             :offset-assert 920)
+   (shock-effect-end  time-frame             :offset-assert 928)
+   (fade              float                  :offset-assert 936)
+   (dest-fade         float                  :offset-assert 940)
+   )
+  :heap-base #x330
+  :method-count-assert 186
+  :size-assert         #x3b0
+  :flag-assert         #xba033003b0
+  (:methods
+    (attack () _type_ :state 178)
+    (backup () _type_ :state 179)
+    (spyder-method-180 (_type_) none 180)
+    (spyder-method-181 (_type_) none 181)
+    (spyder-method-182 (_type_) none 182)
+    (spyder-method-183 (_type_ matrix float) none 183)
+    (spyder-method-184 (_type_ vector) none 184)
+    (spyder-method-185 (_type_) none 185)
+    )
+  )
+
+
+(define *spyder-nav-enemy-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #t
+    :use-victory #t
+    :use-jump-blocked #t
+    :debug-draw-neck #f
+    :jump-debug-draw #f
+    :move-to-ground #t
+    :hover-if-no-ground #f
+    :idle-anim-script (new 'static 'array idle-control-frame 4
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x4 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 4
+    :notice-anim 6
+    :hostile-anim 8
+    :hit-anim 15
+    :knocked-anim 16
+    :knocked-land-anim 20
+    :die-anim 12
+    :die-falling-anim 11
+    :victory-anim 7
+    :jump-wind-up-anim 21
+    :jump-in-air-anim 22
+    :jump-land-anim 23
+    :neck-joint 7
+    :look-at-joint 7
+    :bullseye-joint 28
+    :sound-hit (static-sound-name "spyder-hit")
+    :sound-die (static-sound-name "spyder-die")
+    :notice-distance (meters 80)
+    :notice-distance-delta (meters 10)
+    :proximity-notice-distance (meters 80)
+    :default-hit-points 8
+    :gnd-collide-with (collide-spec backgnd)
+    :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.8
+    :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 2730.6667
+    :knocked-soft-vxz-lo 90112.0
+    :knocked-soft-vxz-hi 131072.0
+    :knocked-soft-vy-lo 114688.0
+    :knocked-soft-vy-hi 155648.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 131072.0
+    :knocked-red-vy-lo 94208.0
+    :knocked-red-vy-hi 139264.0
+    :knocked-blue-vxz-lo 40960.0
+    :knocked-blue-vxz-hi 49152.0
+    :knocked-blue-vy-lo 57344.0
+    :knocked-blue-vy-hi 98304.0
+    :shadow-size (meters 2)
+    :shadow-max-y (meters 1)
+    :shadow-min-y (meters -1)
+    :shadow-locus-dist (meters 150)
+    :gem-joint 7
+    :gem-seg #x2
+    :gem-no-seg #x4
+    :gem-offset (new 'static 'sphere :y 819.2 :z 942.08 :r 163840.0)
+    :callback-info #f
+    :use-momentum #f
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #t
+    :use-pacing #t
+    :walk-anim 5
+    :turn-anim -1
+    :run-anim 8
+    :taunt-anim -1
+    :run-travel-speed (meters 8)
+    :run-acceleration (meters 1)
+    :run-turning-acceleration (meters 50)
+    :walk-travel-speed (meters 4)
+    :walk-acceleration (meters 1)
+    :walk-turning-acceleration (meters 3)
+    :maximum-rotation-rate (degrees 360.0)
+    :notice-nav-radius (meters 35)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 20480.0
+    :circle-dist-hi 61440.0
+    :nav-mesh #f
+    )
+  )
+
+(set! (-> *spyder-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+(defmethod enemy-method-74 spyder ((obj spyder) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (with-pp
+    (case arg2
+      (('hit-knocked)
+       (logclear! (-> obj mask) (process-mask actor-pause))
+       (logclear! (-> obj focus-status) (focus-status dangerous))
+       (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice))
+       (logior! (-> obj enemy-flags) (enemy-flag chase-startup))
+       (logior! (-> obj focus-status) (focus-status hit))
+       (if (zero? (-> obj hit-points))
+           (logior! (-> obj focus-status) (focus-status dead))
+           )
+       (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup))
+       (enemy-method-62 obj)
+       (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
+       (process-contact-action arg0)
+       (send-event arg0 'get-attack-count 1)
+       (when (zero? (-> obj hit-points))
+         (case (-> obj incoming knocked-type)
+           (((knocked-type knocked-type-4) (knocked-type knocked-type-6))
+            (set! (-> obj incoming knocked-type) (knocked-type knocked-type-0))
+            0
+            )
+           )
+         )
+       (go (method-of-object obj knocked))
+       )
+      (('attack)
+       (if (type? (-> arg0 parent 0) enemy)
+           (logior! (-> obj status-flags) 2)
+           )
+       ((method-of-type nav-enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+       )
+      (('notify)
+       (cond
+         ((= (-> arg3 param 0) 'attack)
+          (cond
+            ((= (-> arg3 param 1) (handle->process (-> obj focus handle)))
+             (let ((a1-6 (new 'stack-no-clear 'event-message-block)))
+               (set! (-> a1-6 from) (process->ppointer arg0))
+               (set! (-> a1-6 num-params) (the-as int arg1))
+               (set! (-> a1-6 message) 'victory)
+               (set! (-> a1-6 param 0) (-> arg3 param 0))
+               (set! (-> a1-6 param 1) (-> arg3 param 1))
+               (set! (-> a1-6 param 2) (-> arg3 param 2))
+               (set! (-> a1-6 param 3) (-> arg3 param 3))
+               (set! (-> a1-6 param 4) (-> arg3 param 4))
+               (set! (-> a1-6 param 5) (-> arg3 param 5))
+               (send-event-function obj a1-6)
+               )
+             )
+            (else
+              ((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)
+           )
+         )
+       )
+      (('uncloak)
+       (when (!= (-> obj dest-fade) 128.0)
+         (set! (-> obj shock-effect-end) (+ (-> pp clock frame-counter) (seconds 1)))
+         (set! (-> obj dest-fade) 128.0)
+         (sound-play "spyder-uncloak")
+         )
+       (send-event obj 'cue-chase)
+       ((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 spyder-method-180 spyder ((obj spyder))
+  (with-pp
+    (seek! (-> obj fade) (-> obj dest-fade) (* 500.0 (-> pp clock seconds-per-frame)))
+    (set! (-> obj draw force-fade) (the-as uint (the int (-> obj fade))))
+    (cond
+      ((zero? (-> obj draw force-fade))
+       (setup-masks (-> obj draw) 16 0)
+       (setup-masks (-> obj draw) 0 8)
+       (logclear! (-> obj draw status) (draw-control-status force-fade warp-cross-fade))
+       )
+      ((= (-> obj draw force-fade) 128)
+       (setup-masks (-> obj draw) 0 16)
+       (setup-masks (-> obj draw) 8 0)
+       (logclear! (-> obj draw status) (draw-control-status force-fade warp-cross-fade))
+       )
+      (else
+        (setup-masks (-> obj draw) 16 0)
+        (setup-masks (-> obj draw) 8 0)
+        (logior! (-> obj draw status) (draw-control-status force-fade warp-cross-fade))
+        )
+      )
+    (if (< 245760.0 (vector-vector-distance (-> obj root-override2 trans) (camera-pos)))
+        (setup-masks (-> obj draw) 0 16)
+        )
+    (when (< (-> pp clock frame-counter) (-> obj shock-effect-end))
+      (when (>= (- (-> pp clock frame-counter) (-> obj shock-effect-time)) (seconds 0.04))
+        (set! (-> obj shock-effect-time) (-> pp clock frame-counter))
+        (process-drawable-shock-skel-effect
+          obj
+          (-> *lightning-spec-id-table* 5)
+          lightning-probe-callback
+          (-> *part-id-table* 166)
+          2048.0
+          -1
+          -1
+          )
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+(defmethod spyder-method-181 spyder ((obj spyder))
+  (let ((a0-2 (handle->process (-> obj focus handle))))
+    (when a0-2
+      (let* ((s5-0 (-> obj root-override2 trans))
+             (s2-1 (vector-! (new 'stack-no-clear 'vector) (get-trans (the-as process-focusable a0-2) 0) s5-0))
+             (f0-0 (vector-length s2-1))
+             (s4-0 (new 'stack-no-clear 'vector))
+             )
+        (cond
+          ((>= 143360.0 f0-0)
+           (let ((s3-0 (new 'stack-no-clear 'vector)))
+             (logxor! (-> obj status-flags) 16)
+             (if (logtest? (-> obj status-flags) 16)
+                 (set-vector! s3-0 (-> s2-1 z) (-> s2-1 y) (- (-> s2-1 x)) 1.0)
+                 (set-vector! s3-0 (- (-> s2-1 z)) (-> s2-1 y) (-> s2-1 x) 1.0)
+                 )
+             (vector-normalize! s3-0 (* 4096.0 (rand-vu-float-range 8.0 16.0)))
+             (clamp-vector-to-mesh-cross-gaps
+               (-> obj nav)
+               s5-0
+               (-> obj nav state current-poly)
+               s3-0
+               204.8
+               #f
+               (the-as clamp-travel-vector-to-mesh-return-info #f)
+               )
+             (vector+! s4-0 s5-0 s3-0)
+             )
+           )
+          (else
+            (vector-normalize! s2-1 (+ -122880.0 f0-0))
+            (vector+! s4-0 s5-0 s2-1)
+            )
+          )
+        (set! (-> obj move-dest quad) (-> s5-0 quad))
+        (cloest-point-on-mesh (-> obj nav) (-> obj move-dest) s4-0 (the-as nav-poly #f))
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+;; WARN: Using new Jak 2 rtype-of
+(defmethod enemy-method-77 spyder ((obj spyder) (arg0 (pointer float)))
+  (case (-> obj incoming knocked-type)
+    (((knocked-type knocked-type-4))
+     (let ((a0-2 (-> obj skel root-channel 0)))
+       (set! (-> a0-2 frame-group) (the-as art-joint-anim (-> obj draw art-group data 15)))
+       (set! (-> a0-2 param 0)
+             (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 15)) frames num-frames) -1))
+             )
+       (set! (-> a0-2 param 1) (-> arg0 0))
+       (set! (-> a0-2 frame-num) 0.0)
+       (joint-control-channel-group! a0-2 (the-as art-joint-anim (-> obj draw art-group data 15)) num-func-seek!)
+       )
+     #t
+     )
+    (((knocked-type knocked-type-6))
+     (let* ((a0-4 '((spyder-blue-hit0-ja) (spyder-blue-hit1-ja) (spyder-blue-hit2-ja)))
+            (a1-4 ((method-of-type (rtype-of a0-4) length) a0-4))
+            (s5-0 (new 'static 'array uint64 3 #x11 #x12 #x13))
+            (s4-0 (new 'static 'array int32 4 0 0 0 0))
+            (a2-1 (ash 1 (-> s4-0 0)))
+            (v1-20 (enemy-method-120 obj a1-4 a2-1))
+            (s5-1 (-> obj draw art-group data (-> (the-as (pointer int32) (+ (* v1-20 8) (the-as int s5-0))))))
+            )
+       (set! (-> s4-0 0) v1-20)
+       (let ((v1-23 (if (> (-> obj skel active-channels) 0)
+                        (-> obj skel root-channel 0 frame-group)
+                        )
+                    )
+             )
+         (if (and v1-23 (= v1-23 (-> obj draw art-group data 20)))
+             (ja-channel-push! 1 (seconds 0.17))
+             (ja-channel-push! 1 (seconds 0.02))
+             )
+         )
+       (let ((a0-19 (-> obj skel root-channel 0)))
+         (set! (-> a0-19 frame-group) (the-as art-joint-anim s5-1))
+         (set! (-> a0-19 param 0) (the float (+ (-> (the-as art-joint-anim s5-1) frames num-frames) -1)))
+         (set! (-> a0-19 param 1) 1.0)
+         (set! (-> a0-19 frame-num) 0.0)
+         (joint-control-channel-group! a0-19 (the-as art-joint-anim s5-1) num-func-seek!)
+         )
+       )
+     #t
+     )
+    (((knocked-type knocked-type-0))
+     (cond
+       ((zero? (-> obj hit-points))
+        (let ((a0-20 (-> obj skel root-channel 0)))
+          (set! (-> a0-20 frame-group) (the-as art-joint-anim (-> obj draw art-group data 13)))
+          (set! (-> a0-20 param 0)
+                (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 13)) frames num-frames) -1))
+                )
+          (set! (-> a0-20 param 1) (-> arg0 0))
+          (set! (-> a0-20 frame-num) 0.0)
+          (joint-control-channel-group! a0-20 (the-as art-joint-anim (-> obj draw art-group data 13)) num-func-seek!)
+          )
+        #t
+        )
+       (else
+         ((method-of-type nav-enemy enemy-method-77) obj arg0)
+         )
+       )
+     )
+    (else
+      ((method-of-type nav-enemy enemy-method-77) obj arg0)
+      )
+    )
+  )
+
+(defmethod enemy-method-78 spyder ((obj spyder) (arg0 (pointer float)))
+  (case (-> obj incoming knocked-type)
+    (((knocked-type knocked-type-4))
+     (cond
+       ((zero? (-> obj hit-points))
+        (let ((v1-4 (-> obj skel root-channel 0)))
+          (set! (-> v1-4 frame-group) (the-as art-joint-anim (-> obj draw art-group data 12)))
+          (set! (-> v1-4 param 0)
+                (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 12)) frames num-frames) -1))
+                )
+          (set! (-> v1-4 param 1) 1.0)
+          (set! (-> v1-4 frame-num) 0.0)
+          (joint-control-channel-group! v1-4 (the-as art-joint-anim (-> obj draw art-group data 12)) num-func-seek!)
+          )
+        #t
+        )
+       (else
+         #f
+         )
+       )
+     )
+    (((knocked-type knocked-type-0))
+     (if (zero? (-> obj hit-points))
+         #t
+         ((method-of-type nav-enemy enemy-method-78) obj arg0)
+         )
+     )
+    (else
+      ((method-of-type nav-enemy enemy-method-78) obj arg0)
+      )
+    )
+  )
+
+(defmethod enemy-method-87 spyder ((obj spyder) (arg0 enemy-jump-info))
+  (let ((s5-0 (-> obj draw art-group data (-> obj enemy-info-override jump-in-air-anim))))
+    (let ((v1-6 (if (> (-> obj skel active-channels) 0)
+                    (-> obj skel root-channel 0 frame-group)
+                    )
+                )
+          )
+      (cond
+        ((and v1-6 (= v1-6 (-> obj draw art-group data (-> obj enemy-info-override jump-wind-up-anim))))
+         (ja-channel-push! 1 0)
+         )
+        (else
+          (let ((a0-10 (-> obj skel root-channel 0)))
+            (set! (-> a0-10 param 0) 1.0)
+            (joint-control-channel-group! a0-10 (the-as art-joint-anim #f) num-func-loop!)
+            )
+          (ja-channel-push! 1 (seconds 0.1))
+          )
+        )
+      )
+    (let ((a0-12 (-> obj skel root-channel 0)))
+      (set! (-> a0-12 frame-group) (the-as art-joint-anim s5-0))
+      (set! (-> a0-12 param 0) (the float (+ (-> (the-as art-joint-anim s5-0) frames num-frames) -1)))
+      (set! (-> a0-12 param 1) (-> arg0 anim-speed))
+      (set! (-> a0-12 frame-num) 0.0)
+      (joint-control-channel-group! a0-12 (the-as art-joint-anim s5-0) num-func-seek!)
+      )
+    )
+  #t
+  )
+
+(defbehavior spyder-travel-post spyder ()
+  (set! (-> self face-pos quad) (-> self move-dest quad))
+  (logior! (-> self status-flags) 8)
+  (nav-enemy-travel-post)
+  0
+  (none)
+  )
+
+(defbehavior spyder-face-player-post spyder ()
+  (logior! (-> self status-flags) 8)
+  (let ((gp-0 (handle->process (-> self focus handle)))
+        (f30-0 (-> self nav max-rotation-rate))
+        )
+    (when gp-0
+      (set! (-> self face-pos quad) (-> (get-trans (the-as process-focusable gp-0) 0) quad))
+      (let ((a0-4 self))
+        (if (logtest? (enemy-flag enemy-flag37) (-> a0-4 enemy-flags))
+            (seek-to-point-toward-point!
+              (-> self root-override2)
+              (get-trans (the-as process-focusable gp-0) 0)
+              f30-0
+              (seconds 0.02)
+              )
+            )
+        )
+      )
+    )
+  (nav-enemy-simple-post)
+  0
+  (none)
+  )
+
+(defmethod spyder-method-182 spyder ((obj spyder))
+  (with-pp
+    (cond
+      ((and (logtest? (-> obj status-flags) 4) (!= (-> obj joint scale z) 1.0))
+       (seek! (-> obj joint scale z) 1.0 (* 0.8 (-> pp clock seconds-per-frame)))
+       )
+      ((and (not (logtest? (-> obj status-flags) 4)) (!= (-> obj joint scale z) 0.0))
+       (seek! (-> obj joint scale z) 0.0 (* 0.8 (-> pp clock seconds-per-frame)))
+       )
+      )
+    (let ((s5-0 (new 'stack-no-clear 'quaternion)))
+      (let ((a1-2 (-> obj node-list data 37 bone transform)))
+        (matrix-with-scale->quaternion s5-0 a1-2)
+        )
+      (let ((a1-4 (quaternion-from-two-vectors! (new 'stack-no-clear 'quaternion) (-> obj my-up-vector) *up-vector*)))
+        (quaternion*! s5-0 a1-4 s5-0)
+        )
+      (let ((s4-1 (vector-! (new 'stack-no-clear 'vector) (-> obj face-pos) (-> obj root-override2 trans)))
+            (s3-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
+            )
+        (cond
+          ((logtest? (-> obj status-flags) 8)
+           (vector-! s4-1 (-> obj face-pos) (-> obj root-override2 trans))
+           (set! (-> obj status-flags) (logand -9 (-> obj status-flags)))
+           )
+          (else
+            (set! (-> s4-1 quad) (-> s3-0 quad))
+            )
+          )
+        (set! (-> s4-1 y) 0.0)
+        (vector-xz-normalize! s4-1 1.0)
+        (set! (-> s3-0 y) 0.0)
+        (vector-xz-normalize! s3-0 1.0)
+        (let ((a1-11 (quaternion-from-two-vectors-max-angle! (new 'stack-no-clear 'quaternion) s3-0 s4-1 10012.444)))
+          (quaternion*! s5-0 a1-11 s5-0)
+          )
+        )
+      (quaternion-slerp!
+        (the-as quaternion (-> obj joint twist))
+        (the-as quaternion (-> obj joint twist))
+        s5-0
+        (* 10.0 (-> pp clock seconds-per-frame))
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+(defmethod spyder-method-184 spyder ((obj spyder) (arg0 vector))
+  (with-pp
+    (when (not (logtest? (-> obj status-flags) 1))
+      (let ((s4-0 (new 'stack-no-clear 'vector)))
+        (set! (-> s4-0 quad) (-> *up-vector* quad))
+        (let ((s3-0 (new 'stack-no-clear 'quaternion)))
+          (quaternion-from-two-vectors-max-angle! s3-0 s4-0 (-> obj root-override2 gspot-normal) 4551.1113)
+          (vector-orient-by-quat! s4-0 s4-0 s3-0)
+          )
+        (let ((s3-1 (-> obj my-up-vector)))
+          (vector-deg-seek s3-1 s3-1 s4-0 (* 16384.0 (-> pp clock seconds-per-frame)))
+          (vector-normalize! s3-1 1.0)
+          (forward-up-nopitch->quaternion (-> obj root-override2 quat) arg0 s3-1)
+          )
+        )
+      (logior! (-> obj status-flags) 1)
+      )
+    0
+    (none)
+    )
+  )
+
+(defmethod enemy-method-55 spyder ((obj spyder))
+  (spyder-method-185 obj)
+  (spyder-method-184 obj (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
+  (update-trans! (-> obj sound) (-> obj root-override2 trans))
+  (update! (-> obj sound))
+  (spyder-method-182 obj)
+  (let ((t9-6 (method-of-type nav-enemy enemy-method-55)))
+    (t9-6 obj)
+    )
+  (set! (-> obj status-flags) (logand -2 (-> obj status-flags)))
+  (if (logtest? (-> obj status-flags) 32)
+      (los-control-method-9 (-> obj los) (the-as process-focusable #f) (the-as vector #f) 2048.0)
+      )
+  (if (-> obj predator-effect?)
+      (spyder-method-180 obj)
+      )
+  (none)
+  )
+
+(deftype ik-setup (structure)
+  ((elbow-index int32  :offset-assert   0)
+   (hand-dist   float  :offset-assert   4)
+   )
+  :method-count-assert 9
+  :size-assert         #x8
+  :flag-assert         #x900000008
+  )
+
+
+(define *spyder-ik-setup* (new 'static 'inline-array ik-setup 4
+                            (new 'static 'ik-setup :elbow-index 30 :hand-dist -7577.6)
+                            (new 'static 'ik-setup :elbow-index 32 :hand-dist 7577.6)
+                            (new 'static 'ik-setup :elbow-index 34 :hand-dist 7577.6)
+                            (new 'static 'ik-setup :elbow-index 36 :hand-dist -7577.6)
+                            )
+        )
+
+(defstate notice (spyder)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy notice) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (when (!= (-> self dest-fade) 128.0)
+      (set! (-> self shock-effect-end) (+ (-> self clock frame-counter) (seconds 1)))
+      (set! (-> self dest-fade) 128.0)
+      )
+    (none)
+    )
+  )
+
+(defstate active (spyder)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy active) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (dotimes (gp-0 4)
+      (enable-set! (-> self joint-ik gp-0) #t)
+      )
+    (none)
+    )
+  )
+
+(defmethod spyder-method-185 spyder ((obj spyder))
+  (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 ((s5-0 (new 'stack-no-clear 'collide-query)))
+        (let ((v1-0 (-> s5-0 bbox))
+              (a0-2 (-> obj root-override2 trans))
+              (a1-0 (new 'stack-no-clear 'vector))
+              )
+          (set! (-> a1-0 x) 22528.0)
+          (set! (-> a1-0 y) 22528.0)
+          (set! (-> a1-0 z) 22528.0)
+          (set! (-> a1-0 w) 1.0)
+          (vector-! (the-as vector v1-0) a0-2 a1-0)
+          )
+        (let ((v1-2 (-> s5-0 bbox max))
+              (a0-4 (-> obj root-override2 trans))
+              (a1-1 (new 'stack-no-clear 'vector))
+              )
+          (set! (-> a1-1 x) 22528.0)
+          (set! (-> a1-1 y) 22528.0)
+          (set! (-> a1-1 z) 22528.0)
+          (set! (-> a1-1 w) 1.0)
+          (vector+! v1-2 a0-4 a1-1)
+          )
+        (set! (-> s5-0 collide-with) (collide-spec backgnd))
+        (set! (-> s5-0 ignore-process0) #f)
+        (set! (-> s5-0 ignore-process1) #f)
+        (set! (-> s5-0 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+        (fill-using-bounding-box *collide-cache* s5-0)
+        (dotimes (s4-0 4)
+          (-> obj joint-ik s4-0 shoulder-matrix-no-ik)
+          (let ((a2-8 (-> obj joint-ik s4-0 elbow-matrix-no-ik))
+                (s3-0 (new 'stack-no-clear 'vector))
+                )
+            (let ((v1-15 (new 'stack-no-clear 'vector)))
+              (set! (-> v1-15 quad) (-> *y-vector* quad))
+              (new 'stack-no-clear 'vector)
+              (let ((s2-0 (new 'stack-no-clear 'vector)))
+                (let ((a1-3 s3-0))
+                  (let ((a0-9 (-> a2-8 trans)))
+                    (let ((a2-9 (-> a2-8 vector 1)))
+                      (let ((a3-3 (-> obj joint-ik s4-0 hand-dist)))
+                        (.mov vf7 a3-3)
+                        )
+                      (.lvf vf5 (&-> a2-9 quad))
+                      )
+                    (.lvf vf4 (&-> a0-9 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! (-> s2-0 quad) (-> s3-0 quad))
+                (set! (-> s2-0 y) (-> obj root-override2 trans y))
+                (let ((a2-10 (-> s5-0 start-pos)))
+                  (let ((a0-12 s2-0))
+                    (let ((a1-6 v1-15))
+                      (let ((a3-5 16384.0))
+                        (.mov vf7 a3-5)
+                        )
+                      (.lvf vf5 (&-> a1-6 quad))
+                      )
+                    (.lvf vf4 (&-> a0-12 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 (&-> a2-10 quad) vf6)
+                  )
+                (vector-float*! (-> s5-0 move-dist) v1-15 -32768.0)
+                (let ((v1-16 s5-0))
+                  (set! (-> v1-16 radius) 40.96)
+                  (set! (-> v1-16 collide-with) (collide-spec backgnd))
+                  (set! (-> v1-16 ignore-process0) #f)
+                  (set! (-> v1-16 ignore-process1) #f)
+                  (set! (-> v1-16 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+                  (set! (-> v1-16 action-mask) (collide-action solid))
+                  )
+                (let ((f0-13 (probe-using-line-sphere *collide-cache* s5-0)))
+                  (when (>= f0-13 0.0)
+                    (let ((a1-10 s2-0))
+                      (let ((v1-19 (-> s5-0 start-pos)))
+                        (let ((a0-20 (-> s5-0 move-dist)))
+                          (let ((a2-11 f0-13))
+                            (.mov vf7 a2-11)
+                            )
+                          (.lvf vf5 (&-> a0-20 quad))
+                          )
+                        (.lvf vf4 (&-> v1-19 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-10 quad) vf6)
+                      )
+                    )
+                  )
+                (let ((f0-15 (fmax -8192.0 (fmin 8192.0 (- (-> s2-0 y) (-> s3-0 y))))))
+                  (+! (-> obj delta-y-ik s4-0) (* 10.0 (-> pp clock seconds-per-frame) (- f0-15 (-> obj delta-y-ik s4-0))))
+                  )
+                )
+              )
+            (+! (-> s3-0 y) (-> obj delta-y-ik s4-0))
+            (handle-copy! (-> obj joint-ik s4-0) s3-0)
+            )
+          )
+        )
+      0
+      (none)
+      )
+    )
+  )
+
+(defstate hostile (spyder)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy hostile) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (spyder-method-181 self)
+    (enemy-method-109 self 2)
+    (set! (-> self status-flags) (logand -3 (-> self status-flags)))
+    (when (!= (-> self dest-fade) 128.0)
+      (set! (-> self shock-effect-end) (+ (-> self clock frame-counter) (seconds 1)))
+      (set! (-> self dest-fade) 128.0)
+      (sound-play "spyder-uncloak")
+      )
+    (none)
+    )
+  :exit (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy hostile) exit)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self status-flags) (logand -33 (-> self status-flags)))
+    (enemy-method-109 self 1)
+    (none)
+    )
+  :trans (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy hostile) trans)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (let ((a0-1 (handle->process (-> self focus handle))))
+      (when a0-1
+        (let ((gp-0 (new 'stack-no-clear 'vector)))
+          (set! (-> gp-0 quad) (-> (get-trans (the-as process-focusable a0-1) 0) quad))
+          (let* ((s5-0 (-> self root-override2 trans))
+                 (f30-0 (vector-vector-distance s5-0 gp-0))
+                 (f0-0 (vector-vector-xz-distance s5-0 (-> self move-dest)))
+                 )
+            (cond
+              ((>= (+ 2048.0 (-> self root-override2 nav-radius)) f0-0)
+               (if (and (>= 143360.0 f30-0) (check-los? (-> self los) 0))
+                   (go-virtual attack)
+                   )
+               (spyder-method-181 self)
+               )
+              ((>= 24576.0 f0-0)
+               (logior! (-> self status-flags) 32)
+               )
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :post (behavior ()
+    (let ((a0-0 (-> self nav state))
+          (v1-1 (-> self move-dest))
+          )
+      (logclear! (-> a0-0 flags) (nav-state-flag directional-mode))
+      (logior! (-> a0-0 flags) (nav-state-flag target-poly-dirty))
+      (set! (-> a0-0 target-post quad) (-> v1-1 quad))
+      )
+    0
+    (spyder-travel-post)
+    (none)
+    )
+  )
+
+(defstate backup (spyder)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior spyder) enemy-event-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (let ((v1-2 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-2 enemy-flags)))
+          (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-2 enemy-flags))))
+          )
+      (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-2 enemy-flags))))
+      (set! (-> v1-2 nav callback-info) (-> v1-2 enemy-info-override callback-info))
+      )
+    0
+    (none)
+    )
+  :trans (behavior ()
+    (let ((f0-0 (vector-vector-xz-distance (-> self root-override2 trans) (-> self move-dest))))
+      (if (or (>= 4096.0 f0-0) (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 6)))
+          (go-hostile self)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.1))
+    (until #f
+      (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override run-anim))
+                  :num! (seek!
+                    (the float
+                         (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override run-anim)))
+                                frames
+                                num-frames
+                                )
+                            -1
+                            )
+                         )
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (spyder-travel-post)
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch (pointer process) vs none.
+(defmethod spyder-method-183 spyder ((obj spyder) (arg0 matrix) (arg1 float))
+  (let ((gp-0 (new 'stack-no-clear 'projectile-init-by-other-params)))
+    (let ((v1-0 (-> arg0 vector))
+          (a1-1 (-> arg0 vector 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 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* ((a0-10 *game-info*)
+             (a3-11 (+ (-> a0-10 attack-id) 1))
+             )
+        (set! (-> a0-10 attack-id) a3-11)
+        (set! (-> gp-0 attack-id) a3-11)
+        )
+      (set! (-> gp-0 timeout) (new 'static 'handle :process #x4b0 :u64 #x4b0))
+      (vector-normalize! (vector-! (-> gp-0 vel) a1-1 (the-as vector v1-0)) arg1)
+      )
+    (spawn-projectile spyder-shot gp-0 obj *default-dead-pool*)
+    )
+  (none)
+  )
+
+(defstate attack (spyder)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (let ((v1-0 event-type))
+      (the-as object (if (= v1-0 'event-attack)
+                         (the-as object (spyder-method-183 self (the-as matrix (-> self fire-info)) 307200.0))
+                         (enemy-event-handler proc arg1 event-type event)
+                         )
+              )
+      )
+    )
+  :enter (behavior ()
+    (let ((v1-1 (-> self nav state))
+          (a0-1 (-> self root-override2 trans))
+          )
+      (logclear! (-> v1-1 flags) (nav-state-flag directional-mode))
+      (logior! (-> v1-1 flags) (nav-state-flag target-poly-dirty))
+      (set! (-> v1-1 target-post quad) (-> a0-1 quad))
+      )
+    0
+    (let ((v1-4 self))
+      (set! (-> v1-4 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-4 enemy-flags))))
+      )
+    0
+    (enemy-method-109 self 1)
+    (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags)))
+    (none)
+    )
+  :exit (behavior ()
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (let ((v1-2 (-> self nav)))
+      (set! (-> v1-2 max-rotation-rate) (-> *spyder-nav-enemy-info* maximum-rotation-rate))
+      )
+    0
+    (none)
+    )
+  :trans (behavior ()
+    (if (and (logtest? (-> self enemy-flags) (enemy-flag look-at-focus)) (-> self enemy-info-override use-victory))
+        (go-virtual victory)
+        )
+    (if (or (>= 2 (the-as int (-> self focus aware))) (not (enemy-method-107 self)))
+        (go-stare self)
+        )
+    (none)
+    )
+  :code (behavior ()
+    (when (not (enemy-method-96 self 2730.6667 #t))
+      (ja-channel-push! 1 (seconds 0.2))
+      (ja :group! spyder-patrol0-ja)
+      (ja :num-func num-func-identity :frame-num 0.0)
+      (until (enemy-method-96 self 910.2222 #t)
+        (ja-blend-eval)
+        (suspend)
+        (ja :num! (loop! 0.75))
+        )
+      )
+    (let ((v1-17 (-> self nav)))
+      (set! (-> v1-17 max-rotation-rate) (* 0.05 (-> *spyder-nav-enemy-info* maximum-rotation-rate)))
+      )
+    0
+    (ja-channel-push! 2 (seconds 0.2))
+    (let ((f30-0 0.0))
+      (ja-no-eval :group! spyder-shoot-low-ja :num! (loop!) :frame-num 0.0)
+      (let ((a0-12 (-> self skel root-channel 1)))
+        (set! (-> a0-12 frame-interp 1) f30-0)
+        (set! (-> a0-12 frame-interp 0) f30-0)
+        (set! (-> a0-12 frame-group) (the-as art-joint-anim spyder-shoot-high-ja))
+        (set! (-> a0-12 param 0) 0.0)
+        (set! (-> a0-12 frame-num) 0.0)
+        (joint-control-channel-group! a0-12 (the-as art-joint-anim spyder-shoot-high-ja) num-func-chan)
+        )
+      (let ((a0-14 (handle->process (-> self focus handle))))
+        (when a0-14
+          (let ((gp-0 (new 'stack-no-clear 'vector)))
+            (set! (-> gp-0 quad) (-> (get-trans (the-as process-focusable a0-14) 0) quad))
+            (let ((s5-0 (new 'stack-no-clear 'vector)))
+              (set! (-> s5-0 quad) (-> gp-0 quad))
+              (let ((f28-0 0.0))
+                (dotimes (s4-0 8)
+                  (let* ((f26-0 (fmin (-> self root-override2 trans y) (-> gp-0 y)))
+                         (s3-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 27)))
+                         (f0-11 (fmin 40960.0 (+ -16384.0 (vector-vector-distance s3-0 gp-0))))
+                         (s2-1 (vector-! (new 'stack-no-clear 'vector) s3-0 gp-0))
+                         )
+                    (vector-normalize! s2-1 (- f0-11 f28-0))
+                    (vector+! s2-1 gp-0 s2-1)
+                    (set! (-> s2-1 y) f26-0)
+                    (set! (-> self fire-info 0 quad) (-> s3-0 quad))
+                    (set! (-> self fire-info 1 quad) (-> s2-1 quad))
+                    )
+                  (let ((s3-1 (-> self clock frame-counter)))
+                    (until (>= (- (-> self clock frame-counter) s3-1) (seconds 0.2))
+                      (set! f30-0 (seek f30-0 (lerp-scale 0.0 1.0 (the float s4-0) 0.0 8.0) (-> self clock seconds-per-frame)))
+                      (ja :num! (loop!))
+                      (let ((a0-27 (-> self skel root-channel 1)))
+                        (set! (-> a0-27 frame-interp 1) f30-0)
+                        (set! (-> a0-27 frame-interp 0) f30-0)
+                        (set! (-> a0-27 param 0) 0.0)
+                        (joint-control-channel-group-eval! a0-27 (the-as art-joint-anim #f) num-func-chan)
+                        )
+                      (suspend)
+                      )
+                    )
+                  (let ((f28-1 (+ 12288.0 f28-0)))
+                    (set! (-> gp-0 quad) (-> s5-0 quad))
+                    (let ((a0-31 (handle->process (-> self focus handle))))
+                      (if a0-31
+                          (set! (-> s5-0 quad) (-> (get-trans (the-as process-focusable a0-31) 0) quad))
+                          )
+                      )
+                    (set! f28-0 (fmax 0.0 (- f28-1 (vector-vector-distance gp-0 s5-0))))
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    (until (ja-done? 0)
+      (ja :num! (seek! 2.0))
+      (let ((a0-36 (-> self skel root-channel 1)))
+        (let ((f0-23 1.0))
+          (set! (-> a0-36 frame-interp 1) f0-23)
+          (set! (-> a0-36 frame-interp 0) f0-23)
+          )
+        (set! (-> a0-36 param 0) 0.0)
+        (joint-control-channel-group-eval! a0-36 (the-as art-joint-anim #f) num-func-chan)
+        )
+      (suspend)
+      )
+    (let ((v1-88 self))
+      (set! (-> v1-88 enemy-flags) (the-as enemy-flag (logclear (-> v1-88 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (go-hostile self)
+    (none)
+    )
+  :post (behavior ()
+    (spyder-face-player-post)
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod go-hostile spyder ((obj spyder))
+  (if (and (not (logtest? (-> obj status-flags) 2)) (-> obj next-state) (let ((v1-5 (-> obj next-state name)))
+                                                                          (or (= v1-5 'notice) (= v1-5 'knocked))
+                                                                          )
+           )
+      (go (method-of-object obj attack))
+      )
+  (go (method-of-object obj hostile))
+  (none)
+  )
+
+(defstate knocked (spyder)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy knocked) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self status-flags) (logand -5 (-> self status-flags)))
+    (dotimes (gp-0 4)
+      (enable-set! (-> self joint-ik gp-0) #f)
+      )
+    (none)
+    )
+  :exit (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy knocked) exit)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (when (nonzero? (-> self hit-points))
+      (logior! (-> self status-flags) 4)
+      (dotimes (gp-0 4)
+        (enable-set! (-> self joint-ik gp-0) #t)
+        )
+      )
+    (none)
+    )
+  )
+
+(defstate victory (spyder)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self draw bounds w) 30310.4)
+    (none)
+    )
+  :exit (behavior ()
+    (set! (-> self draw bounds w) 20480.0)
+    (none)
+    )
+  )
+
+(defmethod nav-enemy-method-142 spyder ((obj spyder) (arg0 nav-control))
+  (let ((t9-0 (method-of-object obj spyder-method-184))
+        (a2-0 (-> arg0 state))
+        (a1-1 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> a1-1 quad) (-> a2-0 heading quad))
+    (t9-0 obj a1-1)
+    )
+  0
+  (none)
+  )
+
+(defmethod coin-flip? spyder ((obj spyder))
+  "@returns The result of a 50/50 RNG roll"
+  #f
+  )
+
+;; WARN: Return type mismatch none vs symbol.
+(defmethod enemy-method-63 spyder ((obj spyder) (arg0 process-focusable) (arg1 symbol))
+  (let ((t9-0 (method-of-type nav-enemy enemy-method-63)))
+    (the-as symbol (if (t9-0 obj arg0 arg1)
+                       (set-dst-proc! (-> obj los) (-> obj focus handle))
+                       )
+            )
+    )
+  )
+
+(defmethod enemy-method-114 spyder ((obj spyder))
+  "@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 7) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 8))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec enemy))
+      (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 can-ride deadly no-standon))
+      (set! (-> s4-0 transform-index) 5)
+      (set-vector! (-> s4-0 local-sphere) 0.0 6144.0 0.0 14336.0)
+      (set! (-> s5-0 root-prim) s4-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 enemy))
+      (set! (-> v1-14 prim-core collide-with)
+            (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list)
+            )
+      (set! (-> v1-14 prim-core action) (collide-action solid can-ride deadly))
+      (set-vector! (-> v1-14 local-sphere) 0.0 4915.2 0.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 enemy))
+      (set! (-> v1-16 prim-core collide-with)
+            (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list)
+            )
+      (set! (-> v1-16 prim-core action) (collide-action solid deadly no-standon))
+      (set-vector! (-> v1-16 local-sphere) 0.0 9830.4 0.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 enemy))
+      (set! (-> v1-18 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-18 prim-core action) (collide-action semi-solid deadly))
+      (set! (-> v1-18 transform-index) 5)
+      (set-vector! (-> v1-18 local-sphere) 0.0 0.0 0.0 4915.2)
+      )
+    (let ((v1-20 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-20 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-20 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-20 prim-core action) (collide-action deadly))
+      (set! (-> v1-20 transform-index) 28)
+      (set-vector! (-> v1-20 local-sphere) 0.0 0.0 0.0 2252.8)
+      )
+    (let ((v1-22 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-22 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-22 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-22 prim-core action) (collide-action deadly))
+      (set! (-> v1-22 transform-index) 20)
+      (set-vector! (-> v1-22 local-sphere) 0.0 0.0 0.0 2048.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 enemy))
+      (set! (-> v1-24 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-24 prim-core action) (collide-action deadly))
+      (set! (-> v1-24 transform-index) 10)
+      (set-vector! (-> v1-24 local-sphere) 0.0 0.0 0.0 2048.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 enemy))
+      (set! (-> v1-26 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-26 prim-core action) (collide-action deadly))
+      (set! (-> v1-26 transform-index) 7)
+      (set-vector! (-> v1-26 local-sphere) 0.0 0.0 0.0 2048.0)
+      )
+    (set! (-> s5-0 nav-radius) 12288.0)
+    (let ((v1-28 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-28 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-28 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 process-focusable vs spyder.
+(defmethod relocate spyder ((obj spyder) (arg0 int))
+  (if (nonzero? (-> obj joint))
+      (&+! (-> obj joint) arg0)
+      )
+  (dotimes (v1-4 4)
+    (if (nonzero? (-> obj joint-ik v1-4))
+        (&+! (-> obj joint-ik v1-4) arg0)
+        )
+    )
+  (the-as
+    spyder
+    ((the-as (function process-focusable int process-focusable) (find-parent-method spyder 7)) obj arg0)
+    )
+  )
+
+(defmethod enemy-method-115 spyder ((obj spyder))
+  "@abstract"
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-spyder" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (enemy-method-113 obj *spyder-nav-enemy-info*)
+  (let ((v1-5 (-> obj neck)))
+    (set! (-> v1-5 up) (the-as uint 1))
+    (set! (-> v1-5 nose) (the-as uint 2))
+    (set! (-> v1-5 ear) (the-as uint 0))
+    (set-vector! (-> v1-5 twist-max) 11832.889 11832.889 0.0 1.0)
+    (set! (-> v1-5 ignore-angle) 30947.555)
+    )
+  (let ((v1-7 (-> obj nav)))
+    (set! (-> v1-7 speed-scale) 1.0)
+    )
+  0
+  (set-gravity-length (-> obj root-override2 dynam) 573440.0)
+  (set-vector! (-> obj root-override2 scale) 1.5 1.5 1.5 1.0)
+  (set! (-> obj my-up-vector quad) (-> *up-vector* quad))
+  (set! (-> obj status-flags) (the-as uint 4))
+  (if (rand-vu-percent? 0.5)
+      (logior! (-> obj status-flags) 16)
+      )
+  (set! (-> obj start-pos quad) (-> obj root-override2 trans quad))
+  (set! (-> obj sound)
+        (new 'process 'ambient-sound (static-sound-spec "spyder-talk" :fo-max 70) (-> obj root-override2 trans))
+        )
+  (new-source! (-> obj los) obj (seconds 0.2) (collide-spec backgnd obstacle))
+  (set! (-> obj joint) (the-as joint-mod (new 'process 'joint-mod-blend-world obj 4 #t 1.0)))
+  (set! (-> obj joint scale x) (the-as float (logior (the-as int (-> obj joint scale x)) 4)))
+  (let ((f30-0 (-> obj root-override2 trans y)))
+    (dotimes (s5-1 4)
+      (set! (-> obj joint-ik s5-1)
+            (new 'process 'joint-mod-ik obj (-> *spyder-ik-setup* s5-1 elbow-index) (-> *spyder-ik-setup* s5-1 hand-dist))
+            )
+      (enable-set! (-> obj joint-ik s5-1) #f)
+      (set! (-> obj delta-y-ik 0) f30-0)
+      )
+    )
+  (cond
+    ((>= (res-lump-value (-> obj entity) 'extra-id int :default (the-as uint128 -1) :time -1000000000.0) 0)
+     (setup-masks (-> obj draw) 16 0)
+     (setup-masks (-> obj draw) 8 0)
+     (logior! (-> obj draw status) (draw-control-status force-fade warp-cross-fade))
+     (set! (-> obj draw force-fade) (the-as uint 0))
+     (set! (-> obj fade) 0.0)
+     (set! (-> obj dest-fade) 0.0)
+     (set! (-> obj predator-effect?) #t)
+     )
+    (else
+      (setup-masks (-> obj draw) 0 16)
+      (setup-masks (-> obj draw) 8 0)
+      (set! (-> obj predator-effect?) #f)
+      )
+    )
+  (add-connection *part-engine* obj 7 obj 318 (new 'static 'vector :x 901.12 :y -983.04 :z 942.08 :w 163840.0))
+  (add-connection *part-engine* obj 7 obj 318 (new 'static 'vector :x -901.12 :y -983.04 :z 942.08 :w 163840.0))
+  0
+  (none)
+  )
diff --git a/goal_src/jak2/levels/common/entities/spydroid.gc b/goal_src/jak2/levels/common/entities/spydroid.gc
index 51044783d6..9ea7decee4 100644
--- a/goal_src/jak2/levels/common/entities/spydroid.gc
+++ b/goal_src/jak2/levels/common/entities/spydroid.gc
@@ -7,3 +7,1472 @@
 
 ;; DECOMP BEGINS
 
+(defpartgroup group-spydroid-trail
+  :id 709
+  :bounds (static-bspherem 0 0 0 8)
+  :parts ((sp-item 3162 :fade-after (meters 120) :falloff-to (meters 160))
+    (sp-item 3163 :flags (bit6))
+    (sp-item 3164 :fade-after (meters 120) :falloff-to (meters 160))
+    )
+  )
+
+(defpart 3163
+  :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.5))
+    (sp-rnd-flt spt-scale-x (meters 1.7) (meters 1) 1.0)
+    (sp-flt spt-rot-x 2048.0)
+    (sp-rnd-flt spt-rot-z (degrees -17.0) (degrees 17.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 0.0)
+    (sp-rnd-flt spt-g 192.0 64.0 1.0)
+    (sp-flt spt-b 255.0)
+    (sp-flt spt-a 16.0)
+    (sp-flt spt-omega 1230848.0)
+    (sp-flt spt-fade-a -1.0666667)
+    (sp-int spt-timer 10)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 3072.0)
+    )
+  )
+
+(defpart 3164
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x92 :page #xc))
+    (sp-rnd-flt spt-num 2.0 2.0 1.0)
+    (sp-flt spt-scale-x (meters 2.5))
+    (sp-int spt-rot-x 4)
+    (sp-flt spt-scale-y (meters 0.033))
+    (sp-flt spt-r 128.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-omega 6.144)
+    (sp-rnd-flt spt-vel-y (meters 0.06666667) (meters 0.06666667) 1.0)
+    (sp-flt spt-fade-r -8.0)
+    (sp-rnd-flt spt-fade-g -0.85 -0.85 1.0)
+    (sp-rnd-flt spt-fade-a -0.10666667 -0.42666668 1.0)
+    (sp-rnd-flt spt-accel-y -6.826667 -2.7306666 1.0)
+    (sp-flt spt-friction 0.96)
+    (sp-int-plain-rnd spt-timer 300 299 1)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-3)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-rnd-flt spt-conerot-x (degrees 135.0) (degrees 90.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-flt spt-conerot-radius (meters -0.5))
+    )
+  )
+
+(defpart 3162
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.5 1.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1.2) (meters 0.8) 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 0.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 64.0 8.0 1.0)
+    (sp-rnd-flt spt-vel-x (meters -0.0033333334) (meters 0.006666667) 1.0)
+    (sp-rnd-flt spt-vel-y (meters -0.006666667) (meters -0.006666667) 1.0)
+    (sp-rnd-flt spt-vel-z (meters -0.0033333334) (meters 0.006666667) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.006666667) (meters 0.008333334) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.3) (degrees 0.6) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 3.2)
+    (sp-flt spt-fade-g 0.0)
+    (sp-flt spt-fade-b -3.2)
+    (sp-flt spt-fade-a -0.8)
+    (sp-rnd-flt spt-accel-y 0.4096 0.13653333 1.0)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 600)
+    (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 40)
+    (sp-launcher-by-id spt-next-launcher 3165)
+    )
+  )
+
+(defpart 3165
+  :init-specs ((sp-flt spt-r 128.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (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.10666667 -0.21333334 1.0)
+    (sp-func spt-func 'nothing)
+    )
+  )
+
+(defpartgroup group-spydroid-explode
+  :id 710
+  :duration (seconds 3)
+  :linger-duration (seconds 1)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 15)
+  :parts ((sp-item 3166 :flags (bit6) :period 900 :length 5)
+    (sp-item 3167 :flags (bit6) :period 900 :length 5)
+    (sp-item 3168 :period 900 :length 15)
+    (sp-item 3169 :fade-after (meters 60) :period 900 :length 10 :offset 10)
+    (sp-item 3170 :fade-after (meters 60) :falloff-to (meters 60) :period 900 :length 50 :offset 20)
+    (sp-item 3171 :fade-after (meters 200) :falloff-to (meters 200) :period 900 :length 25 :offset 20)
+    (sp-item 3172 :fade-after (meters 150) :falloff-to (meters 150) :period 900 :length 20 :offset 30)
+    )
+  )
+
+(defpart 3167
+  :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 2))
+    (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.10666667))
+    (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 -8.5)
+    (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 3173)
+    )
+  )
+
+(defpart 3173
+  :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 3172
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x34 :page #xc))
+    (sp-rnd-flt spt-num 2.0 0.2 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 655360.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.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-int spt-next-time 25)
+    (sp-launcher-by-id spt-next-launcher 3174)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-conerot-x)
+      :flags (sp-flag from-pointer)
+      :func '*sp-temp*
+      )
+    )
+  )
+
+(defpart 3171
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x33 :page #xc))
+    (sp-rnd-flt spt-num 1.0 0.2 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-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-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 spt-next-time 25)
+    (sp-launcher-by-id spt-next-launcher 3174)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defpart 3174
+  :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 3175)
+    )
+  )
+
+(defpart 3175
+  :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 3176)
+    )
+  )
+
+(defpart 3176
+  :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 3177)
+    )
+  )
+
+(defpart 3177
+  :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 3166
+  :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 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 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 3178)
+    )
+  )
+
+(defpart 3178
+  :init-specs ((sp-flt spt-scalevel-x (meters -0.2857143))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -3.6571429)
+    (sp-flt spt-fade-b 0.0)
+    (sp-flt spt-fade-a -2.7428572)
+    )
+  )
+
+(defpart 3170
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x32 :page #xc))
+    (sp-rnd-flt spt-num 8.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 -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 3179)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defpart 3179
+  :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 3180)
+    )
+  )
+
+(defpart 3180
+  :init-specs ((sp-flt spt-fade-r -0.5543478) (sp-flt spt-fade-g -0.5543478) (sp-flt spt-fade-a -0.13913043))
+  )
+
+(defpart 3168
+  :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 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 3181)
+    (sp-rnd-flt spt-conerot-x (degrees -1440.0) (degrees 2880.0) 1.0)
+    )
+  )
+
+(defpart 3181
+  :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 3182)
+    )
+  )
+
+(defpart 3182
+  :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 3169
+  :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 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 90)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    )
+  )
+
+(defpart 3183
+  :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 0.75))
+    (sp-flt spt-rot-x 204.8)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 0.0)
+    (sp-flt spt-b 0.0)
+    (sp-flt spt-a 16.0)
+    (sp-flt spt-omega 247808.0)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 409.6)
+    )
+  )
+
+(defpart 3184
+  :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 0.5))
+    (sp-flt spt-rot-x 204.8)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 0.0)
+    (sp-rnd-flt spt-g 128.0 64.0 1.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 16.0 4.0 1.0)
+    (sp-flt spt-omega 247808.0)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 409.6)
+    )
+  )
+
+(defpart 3185
+  :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 2) (meters 0.2) 1.0)
+    (sp-flt spt-rot-x 204.8)
+    (sp-rnd-flt spt-rot-z (degrees -2.0) (degrees 4.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 0.0)
+    (sp-rnd-flt spt-g 128.0 64.0 1.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 6.0 2.0 1.0)
+    (sp-flt spt-omega 329728.0)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 409.6)
+    )
+  )
+
+(defpart 3186
+  :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.75) (meters 0.1) 1.0)
+    (sp-flt spt-rot-x 204.8)
+    (sp-rnd-flt spt-rot-z (degrees -2.0) (degrees 4.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 64.0)
+    (sp-rnd-flt spt-g 128.0 64.0 1.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 32.0 4.0 1.0)
+    (sp-flt spt-omega 329728.0)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 409.6)
+    )
+  )
+
+(defskelgroup skel-spydroid spydroid spydroid-lod0-jg spydroid-idle-ja
+              ((spydroid-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              :shadow spydroid-shadow-mg
+              )
+
+(defskelgroup skel-spydroid-exploding spydroid spydroid-exploding-lod0-jg spydroid-exploding-idle-ja
+              ((spydroid-exploding-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 12)
+              )
+
+(define *spydroid-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 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 17 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 18 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 19 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 21 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 22 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 25 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 26 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 27 :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 23 :parent-joint-index -1)
+      )
+    :collide-spec #x241
+    )
+  )
+
+(deftype spydroid (nav-enemy)
+  ((old-y-deg    float                      :offset-assert 604)
+   (diff-angle   float                      :offset-assert 608)
+   (desire-turn  symbol                     :offset-assert 612)
+   (hit-target   basic                      :offset-assert 616)
+   (lightning    lightning-control        4 :offset-assert 620)
+   (floor        float                      :offset-assert 636)
+   (explode-part sparticle-launch-control   :offset-assert 640)
+   )
+  :heap-base #x210
+  :method-count-assert 179
+  :size-assert         #x284
+  :flag-assert         #xb302100284
+  (:methods
+    (attack () _type_ :state 178)
+    )
+  )
+
+
+(define *spydroid-nav-enemy-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 #f
+    :hover-if-no-ground #f
+    :idle-anim-script (new 'static 'array idle-control-frame 4
+      (new 'static 'idle-control-frame :command (ic-cmd push) :param0 #x1e)
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x3 :param0 #x64 :param1 #x64)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 3
+    :notice-anim 3
+    :hostile-anim 5
+    :hit-anim 15
+    :knocked-anim 11
+    :knocked-land-anim 12
+    :die-anim 15
+    :die-falling-anim 15
+    :victory-anim -1
+    :jump-wind-up-anim 8
+    :jump-in-air-anim 9
+    :jump-land-anim 10
+    :neck-joint 4
+    :look-at-joint 4
+    :bullseye-joint 4
+    :sound-hit (static-sound-name "spydroid-hit")
+    :sound-die (static-sound-name "spydroid-die")
+    :notice-distance (meters 200)
+    :notice-distance-delta (meters 10)
+    :proximity-notice-distance (meters 20)
+    :default-hit-points 1
+    :gnd-collide-with (collide-spec backgnd obstacle hit-by-others-list)
+    :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+    :movement-gravity (meters -100)
+    :friction 0.8
+    :attack-shove-back (meters 3.5)
+    :attack-shove-up (meters 2)
+    :attack-mode 'shock
+    :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 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)
+    :callback-info #f
+    :use-momentum #t
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #t
+    :use-pacing #t
+    :walk-anim 4
+    :turn-anim -1
+    :run-anim 5
+    :taunt-anim -1
+    :run-travel-speed (meters 8)
+    :run-acceleration (meters 32)
+    :run-turning-acceleration (meters 40)
+    :walk-travel-speed (meters 4)
+    :walk-acceleration (meters 16)
+    :walk-turning-acceleration (meters 40)
+    :maximum-rotation-rate (degrees 360.0)
+    :notice-nav-radius (meters 2)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 20480.0
+    :circle-dist-hi 61440.0
+    :nav-mesh #f
+    )
+  )
+
+(set! (-> *spydroid-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+(defmethod enemy-method-55 spydroid ((obj spydroid))
+  (let ((t9-0 (method-of-type nav-enemy enemy-method-55)))
+    (t9-0 obj)
+    )
+  (when (< (-> obj root-override2 scale x) 1.0)
+    (let ((f0-2 (fmin 1.0 (+ 0.025 (-> obj root-override2 scale x)))))
+      (set-vector! (-> obj root-override2 scale) f0-2 f0-2 f0-2 1.0)
+      )
+    )
+  (let ((s5-0 (new 'stack-no-clear 'vector))
+        (s4-0 (new 'stack-no-clear 'vector))
+        )
+    (vector<-cspace! s5-0 (-> obj node-list data 12))
+    (dotimes (s3-0 4)
+      (let ((a0-4 (-> obj lightning s3-0))
+            (v1-12 s5-0)
+            )
+        (set! (-> a0-4 state meet data 0 quad) (-> v1-12 quad))
+        )
+      (let ((v1-14 s3-0))
+        (cond
+          ((zero? v1-14)
+           (vector<-cspace! s4-0 (-> obj node-list data 16))
+           )
+          ((= v1-14 1)
+           (vector<-cspace! s4-0 (-> obj node-list data 20))
+           )
+          ((= v1-14 2)
+           (vector<-cspace! s4-0 (-> obj node-list data 28))
+           )
+          (else
+            (vector<-cspace! s4-0 (-> obj node-list data 24))
+            )
+          )
+        )
+      (let ((a0-13 (-> obj lightning s3-0))
+            (v1-25 s4-0)
+            )
+        (set! (-> a0-13 state meet data (+ (-> a0-13 state points-to-draw) -1) quad) (-> v1-25 quad))
+        )
+      (when (not (and (-> obj next-state) (= (-> obj next-state name) 'die-falling)))
+        (case (-> obj lightning s3-0 state mode)
+          (((lightning-mode lm0) (lightning-mode lm3))
+           (let ((v1-39 (-> obj lightning s3-0))
+                 (a0-19 1)
+                 )
+             (let ((a1-10 (!= a0-19 (-> v1-39 state mode))))
+               (case a0-19
+                 ((3)
+                  (if a1-10
+                      (set! (-> v1-39 state counter) 0.0)
+                      )
+                  )
+                 ((1)
+                  (set! (-> v1-39 state start-color) (-> v1-39 spec start-color))
+                  (set! (-> v1-39 state end-color) (-> v1-39 spec end-color))
+                  )
+                 )
+               )
+             (set! (-> v1-39 state mode) (the-as lightning-mode a0-19))
+             )
+           )
+          )
+        )
+      )
+    )
+  (let ((f0-5 (quaternion-y-angle (-> obj root-override2 quat))))
+    (set! (-> obj diff-angle) (- (-> obj old-y-deg) f0-5))
+    (cond
+      ((< 32768.0 (-> obj diff-angle))
+       (set! (-> obj diff-angle) (+ -65536.0 (-> obj diff-angle)))
+       )
+      ((< (-> obj diff-angle) -32768.0)
+       (set! (-> obj diff-angle) (+ 65536.0 (-> obj diff-angle)))
+       )
+      )
+    (set! (-> obj old-y-deg) f0-5)
+    )
+  (set! (-> obj desire-turn)
+        (< (+ 0.5 (* 0.00024414062 (-> obj nav state speed))) (* 0.005493164 (fabs (-> obj diff-angle))))
+        )
+  (if (and (< (-> obj root-override2 trans y) (+ -122880.0 (-> obj floor)))
+           (-> obj next-state)
+           (= (-> obj next-state name) 'jump)
+           )
+      (deactivate obj)
+      )
+  (if (and (-> obj next-state) (= (-> obj next-state name) 'jump))
+      (spawn (-> obj part) (-> obj root-override2 trans))
+      )
+  0
+  (none)
+  )
+
+(defmethod enemy-method-74 spydroid ((obj spydroid) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (local-vars (v1-6 vector) (sv-144 vector))
+  (with-pp
+    (rlet ((vf0 :class vf)
+           (vf4 :class vf)
+           (vf5 :class vf)
+           (vf6 :class vf)
+           )
+      (init-vf0-vector)
+      (case arg2
+        (('touch 'bonk 'attack)
+         (set! sv-144 (the-as vector (send-event (ppointer->process (-> obj parent)) 'widow-get-center)))
+         (let* ((s1-0 arg0)
+                (s0-0 (if (type? s1-0 process-drawable)
+                          s1-0
+                          )
+                      )
+                )
+           (let ((v1-5 sv-144))
+             (b! (not v1-5) cfg-15 :likely-delay (set! v1-6 sv-144))
+             )
+           (set! v1-6 (the-as vector s0-0))
+           (label cfg-15)
+           (cond
+             (v1-6
+               (let ((v1-9 (vector-! (new 'stack-no-clear 'vector) (-> obj root-override2 trans) sv-144))
+                     (s1-1 (new 'stack-no-clear 'vector))
+                     )
+                 (set! (-> s1-1 x) (- (-> v1-9 z)))
+                 (set! (-> s1-1 y) 0.0)
+                 (set! (-> s1-1 z) (-> v1-9 x))
+                 (set! (-> s1-1 w) 1.0)
+                 (let ((v1-12 (vector-!
+                                (new 'stack-no-clear 'vector)
+                                (-> (the-as process-drawable s0-0) root trans)
+                                (-> obj root-override2 trans)
+                                )
+                              )
+                       )
+                   (set! (-> s1-1 y) 0.0)
+                   (set! (-> v1-12 y) 0.0)
+                   (if (< (vector-dot v1-12 s1-1) 0.0)
+                       (vector-negate! s1-1 s1-1)
+                       )
+                   )
+                 (vector-normalize! s1-1 16384.0)
+                 (vector+! s1-1 s1-1 (-> (the-as process-drawable s0-0) root trans))
+                 (vector-! s1-1 s1-1 sv-144)
+                 (set! (-> s1-1 y) 0.0)
+                 (vector-normalize! s1-1 204800.0)
+                 (let ((v1-17 s1-1))
+                   (let ((a0-19 s1-1))
+                     (.mov.vf vf6 vf0 :mask #b1000)
+                     (.lvf vf4 (&-> a0-19 quad))
+                     )
+                   (.lvf vf5 (&-> (the-as vector sv-144) quad))
+                   (.add.vf vf6 vf4 vf5 :mask #b111)
+                   (.svf (&-> v1-17 quad) vf6)
+                   )
+                 (vector-! s1-1 s1-1 (-> (the-as process-drawable s0-0) root trans))
+                 (set! (-> s1-1 y) 8192.0)
+                 (let ((a1-17 (new 'stack-no-clear 'event-message-block)))
+                   (set! (-> a1-17 from) (process->ppointer pp))
+                   (set! (-> a1-17 num-params) 2)
+                   (set! (-> a1-17 message) 'attack)
+                   (set! (-> a1-17 param 0) (the-as uint #f))
+                   (let ((v1-23 (new 'static 'attack-info :mask (attack-info-mask vector mode id))))
+                     (let* ((a0-24 *game-info*)
+                            (a2-2 (+ (-> a0-24 attack-id) 1))
+                            )
+                       (set! (-> a0-24 attack-id) a2-2)
+                       (set! (-> v1-23 id) a2-2)
+                       )
+                     (set! (-> v1-23 mode) 'shock)
+                     (set! (-> v1-23 vector quad) (-> s1-1 quad))
+                     (set! (-> a1-17 param 1) (the-as uint v1-23))
+                     )
+                   (send-event-function arg0 a1-17)
+                   )
+                 )
+               )
+             (else
+               (let ((a1-18 (new 'stack-no-clear 'event-message-block)))
+                 (set! (-> a1-18 from) (process->ppointer pp))
+                 (set! (-> a1-18 num-params) 2)
+                 (set! (-> a1-18 message) 'attack)
+                 (set! (-> a1-18 param 0) (the-as uint #f))
+                 (let ((v1-28 (new 'static 'attack-info :mask (attack-info-mask mode shove-back shove-up id))))
+                   (let* ((a0-29 *game-info*)
+                          (a2-4 (+ (-> a0-29 attack-id) 1))
+                          )
+                     (set! (-> a0-29 attack-id) a2-4)
+                     (set! (-> v1-28 id) a2-4)
+                     )
+                   (set! (-> v1-28 mode) 'shock)
+                   (set! (-> v1-28 shove-up) 8192.0)
+                   (set! (-> v1-28 shove-back) 16384.0)
+                   (set! (-> a1-18 param 1) (the-as uint v1-28))
+                   )
+                 (send-event-function arg0 a1-18)
+                 )
+               )
+             )
+           )
+         (let ((v1-30 (the-as object (-> arg3 param 1))))
+           (if (or (!= arg0 *target*)
+                   (and (= arg2 'attack)
+                        (logtest? (attack-info-mask penetrate-using) (-> (the-as attack-info v1-30) mask))
+                        (logtest? (penetrate dark-bomb) (-> (the-as attack-info v1-30) penetrate-using))
+                        )
+                   )
+               ((method-of-type nav-enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+               )
+           )
+         )
+        (('jump)
+         (set! (-> obj floor) (-> (the-as vector (-> arg3 param 1)) y))
+         ((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)
+          )
+        )
+      )
+    )
+  )
+
+(defstate die-falling (spydroid)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy die-falling) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :trans (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy die-falling) trans)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (if (< (- (-> self clock frame-counter) (-> self state-time)) (seconds 2))
+        (spawn (-> self explode-part) (-> self root-override2 trans))
+        )
+    (none)
+    )
+  :code (behavior ()
+    (dotimes (v1-0 4)
+      (let ((a0-2 (-> self lightning v1-0))
+            (a1-0 3)
+            )
+        (let ((a2-1 (!= a1-0 (-> a0-2 state mode))))
+          (case a1-0
+            ((3)
+             (if a2-1
+                 (set! (-> a0-2 state counter) 0.0)
+                 )
+             )
+            ((1)
+             (set! (-> a0-2 state start-color) (-> a0-2 spec start-color))
+             (set! (-> a0-2 state end-color) (-> a0-2 spec end-color))
+             )
+            )
+          )
+        (set! (-> a0-2 state mode) (the-as lightning-mode a1-0))
+        )
+      )
+    ((lambda :behavior spydroid
+       ()
+       (let ((gp-0 (new 'stack 'joint-exploder-tuning (the-as uint 0))))
+         (process-spawn
+           joint-exploder
+           (art-group-get-by-name *level* "skel-spydroid-exploding" (the-as (pointer uint32) #f))
+           20
+           gp-0
+           *spydroid-exploder-params*
+           :to self
+           )
+         )
+       )
+     )
+    (suspend)
+    (ja-channel-set! 0)
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 1))
+        (suspend)
+        )
+      )
+    (send-event self 'death-end)
+    (while (-> self child)
+      (suspend)
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+(defstate attack (spydroid)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior spydroid) enemy-event-handler)
+  :enter (behavior ()
+    (set! (-> self hit-target) #f)
+    (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags)))
+    (let ((v1-2 (-> self nav)))
+      (set! (-> v1-2 target-speed) (+ 8192.0 (-> self enemy-info-override run-travel-speed)))
+      )
+    0
+    (let ((v1-5 (-> self nav state)))
+      (set! (-> v1-5 speed) (+ 8192.0 (-> self enemy-info-override run-travel-speed)))
+      )
+    0
+    (let ((v1-7 (-> self nav)))
+      (set! (-> v1-7 turning-acceleration) (* 4.0 (-> self enemy-info-override run-turning-acceleration)))
+      )
+    0
+    (set! (-> self root-override2 penetrate-using) (penetrate generic-attack lunge))
+    (enemy-method-49 self)
+    (logior! (-> self focus-status) (focus-status dangerous))
+    (let* ((v1-14 *game-info*)
+           (a0-10 (+ (-> v1-14 attack-id) 1))
+           )
+      (set! (-> v1-14 attack-id) a0-10)
+      (set! (-> self attack-id) a0-10)
+      )
+    (ja-channel-push! 1 (seconds 0.1))
+    (ja :group! spydroid-attack-jump-ja :num! min)
+    (none)
+    )
+  :exit (behavior ()
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (nav-enemy-method-168 self)
+    (let ((v1-4 (-> self nav)))
+      (set! (-> v1-4 target-speed) (-> self enemy-info-override run-travel-speed))
+      )
+    0
+    (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 ()
+    (enemy-method-49 self)
+    nav-state
+    (if (logtest? (-> self enemy-flags) (enemy-flag look-at-focus))
+        (set! (-> self hit-target) (the-as basic #t))
+        )
+    (let ((v1-9 (ja-group)))
+      (cond
+        ((and v1-9 (= v1-9 spydroid-attack-jump-ja))
+         (ja :num! (seek!))
+         (when (ja-done? 0)
+           (let ((v1-20 (-> self nav)))
+             (set! (-> v1-20 target-speed) 0.0)
+             )
+           0
+           (let ((v1-22 (-> self nav)))
+             (set! (-> v1-22 acceleration) 262144.0)
+             )
+           0
+           (let ((v1-24 (-> self nav)))
+             (set! (-> v1-24 turning-acceleration) 0.0)
+             )
+           0
+           (ja :group! spydroid-attack-land-ja :num! min)
+           )
+         )
+        ((let ((v1-32 (ja-group)))
+           (and v1-32 (= v1-32 spydroid-attack-land-ja))
+           )
+         (ja :num! (seek!))
+         (cond
+           ((ja-done? 0)
+            (if (-> self hit-target)
+                (go-virtual victory)
+                (go-hostile self)
+                )
+            )
+           ((not (-> self desire-turn))
+            )
+           ((< 0.0 (-> self diff-angle))
+            (ja-channel-push! 1 (seconds 0.1))
+            (ja :group! spydroid-turn-left-ja :num! min)
+            )
+           (else
+             (ja-channel-push! 1 (seconds 0.1))
+             (ja :group! spydroid-turn-right-ja :num! min)
+             )
+           )
+         )
+        ((let ((v1-58 (ja-group)))
+           (and (and v1-58 (= v1-58 spydroid-turn-left-ja)) (and (-> self desire-turn) (< 0.0 (-> self diff-angle))))
+           )
+         (ja :num! (loop! (* 0.0019975142 (-> self diff-angle))))
+         )
+        (else
+          (let ((v1-68 (ja-group)))
+            (cond
+              ((and (and v1-68 (= v1-68 spydroid-turn-right-ja)) (and (-> self desire-turn) (< (-> self diff-angle) 0.0)))
+               (ja :num! (loop! (* -0.0019975142 (-> self diff-angle))))
+               )
+              ((-> self hit-target)
+               (go-virtual victory)
+               )
+              (else
+                (go-hostile self)
+                )
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior spydroid) sleep-code)
+  :post (the-as (function none :behavior spydroid) nav-enemy-chase-post)
+  )
+
+(defstate notice (spydroid)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy notice) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (enemy-method-72 self)
+    (none)
+    )
+  )
+
+(defstate hostile (spydroid)
+  :virtual #t
+  :trans (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy hostile) trans)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (let ((a0-1 (handle->process (-> self focus handle))))
+      (if (and (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+               (and a0-1 (let ((f0-0 (vector-vector-xz-distance-squared
+                                       (get-trans (the-as process-focusable a0-1) 0)
+                                       (-> self root-override2 trans)
+                                       )
+                                     )
+                               (f1-0 16384.0)
+                               )
+                           (< f0-0 (* f1-0 f1-0))
+                           )
+                    )
+               )
+          (go-virtual attack)
+          )
+      )
+    (cond
+      ((not (-> self desire-turn))
+       (let ((v1-23 (ja-group)))
+         (when (not (and v1-23 (= v1-23 (-> self draw art-group data (-> self enemy-info-override hostile-anim)))))
+           (ja-channel-push! 1 (seconds 0.1))
+           (ja :group! (-> self draw art-group data (-> self enemy-info-override hostile-anim)) :num! min)
+           )
+         )
+       (ja :num! (loop! (/ (-> self nav state speed) (* 0.5 (-> self enemy-info-override run-travel-speed)))))
+       )
+      ((< 0.0 (-> self diff-angle))
+       (let ((v1-43 (ja-group)))
+         (cond
+           ((not (and v1-43 (= v1-43 spydroid-turn-left-ja)))
+            (ja-channel-push! 1 (seconds 0.1))
+            (ja :group! spydroid-turn-left-ja :num! min)
+            )
+           (else
+             (ja :num! (loop! (* 0.0019975142 (-> self diff-angle))))
+             )
+           )
+         )
+       )
+      (else
+        (let ((v1-55 (ja-group)))
+          (cond
+            ((not (and v1-55 (= v1-55 spydroid-turn-right-ja)))
+             (ja-channel-push! 1 (seconds 0.1))
+             (ja :group! spydroid-turn-right-ja :num! min)
+             )
+            (else
+              (ja :num! (loop! (* -0.0019975142 (-> self diff-angle))))
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (logior! (-> self mask) (process-mask sleep-code))
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  )
+
+(defstate circling (spydroid)
+  :virtual #t
+  :trans (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy circling) trans)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (cond
+      ((not (-> self desire-turn))
+       (let ((v1-7 (ja-group)))
+         (when (not (and v1-7 (= v1-7 (-> self draw art-group data (-> self enemy-info-override walk-anim)))))
+           (ja-channel-push! 1 (seconds 0.1))
+           (ja :group! (-> self draw art-group data (-> self enemy-info-override walk-anim)) :num! min)
+           )
+         )
+       (ja :num! (loop! (/ (-> self nav state speed) (* 0.5 (-> self enemy-info-override run-travel-speed)))))
+       )
+      ((< 0.0 (-> self diff-angle))
+       (let ((v1-27 (ja-group)))
+         (cond
+           ((not (and v1-27 (= v1-27 spydroid-turn-left-ja)))
+            (ja-channel-push! 1 (seconds 0.1))
+            (ja :group! spydroid-turn-left-ja :num! min)
+            )
+           (else
+             (ja :num! (loop! (* 0.0019975142 (-> self diff-angle))))
+             )
+           )
+         )
+       )
+      (else
+        (let ((v1-39 (ja-group)))
+          (cond
+            ((not (and v1-39 (= v1-39 spydroid-turn-right-ja)))
+             (ja-channel-push! 1 (seconds 0.1))
+             (ja :group! spydroid-turn-right-ja :num! min)
+             )
+            (else
+              (ja :num! (loop! (* -0.0019975142 (-> self diff-angle))))
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (nav-enemy-method-165 self)
+    (until #f
+      (logior! (-> self mask) (process-mask sleep-code))
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  )
+
+(defstate pacing (spydroid)
+  :virtual #t
+  :trans (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy pacing) trans)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (cond
+      ((not (-> self desire-turn))
+       (let ((v1-7 (ja-group)))
+         (when (not (and v1-7 (= v1-7 (-> self draw art-group data (-> self enemy-info-override walk-anim)))))
+           (ja-channel-push! 1 (seconds 0.1))
+           (ja :group! (-> self draw art-group data (-> self enemy-info-override walk-anim)) :num! min)
+           )
+         )
+       (ja :num! (loop! (/ (-> self nav state speed) (* 0.5 (-> self enemy-info-override run-travel-speed)))))
+       )
+      ((< 0.0 (-> self diff-angle))
+       (let ((v1-27 (ja-group)))
+         (cond
+           ((not (and v1-27 (= v1-27 spydroid-turn-left-ja)))
+            (ja-channel-push! 1 (seconds 0.1))
+            (ja :group! spydroid-turn-left-ja :num! min)
+            )
+           (else
+             (ja :num! (loop! (* 0.0019975142 (-> self diff-angle))))
+             )
+           )
+         )
+       )
+      (else
+        (let ((v1-39 (ja-group)))
+          (cond
+            ((not (and v1-39 (= v1-39 spydroid-turn-right-ja)))
+             (ja-channel-push! 1 (seconds 0.1))
+             (ja :group! spydroid-turn-right-ja :num! min)
+             )
+            (else
+              (ja :num! (loop! (* -0.0019975142 (-> self diff-angle))))
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (logior! (-> self mask) (process-mask sleep-code))
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  )
+
+(defstate stare (spydroid)
+  :virtual #t
+  :trans (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy stare) trans)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (cond
+      ((not (-> self desire-turn))
+       (let ((v1-7 (ja-group)))
+         (when (not (and v1-7 (= v1-7 (-> self draw art-group data (-> self enemy-info-override idle-anim)))))
+           (ja-channel-push! 1 (seconds 0.1))
+           (ja :group! (-> self draw art-group data (-> self enemy-info-override idle-anim)) :num! min)
+           )
+         )
+       (ja :num! (loop!))
+       )
+      ((< 0.0 (-> self diff-angle))
+       (let ((v1-23 (ja-group)))
+         (cond
+           ((not (and v1-23 (= v1-23 spydroid-turn-left-ja)))
+            (ja-channel-push! 1 (seconds 0.1))
+            (ja :group! spydroid-turn-left-ja :num! min)
+            )
+           (else
+             (ja :num! (loop! (* 0.0019975142 (-> self diff-angle))))
+             )
+           )
+         )
+       )
+      (else
+        (let ((v1-35 (ja-group)))
+          (cond
+            ((not (and v1-35 (= v1-35 spydroid-turn-right-ja)))
+             (ja-channel-push! 1 (seconds 0.1))
+             (ja :group! spydroid-turn-right-ja :num! min)
+             )
+            (else
+              (ja :num! (loop! (* -0.0019975142 (-> self diff-angle))))
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (logior! (-> self mask) (process-mask sleep-code))
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  )
+
+(defmethod enemy-method-114 spydroid ((obj spydroid))
+  "@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 ((v1-7 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-7 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-7 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-7 prim-core action) (collide-action deadly))
+      (set! (-> v1-7 transform-index) 3)
+      (set-vector! (-> v1-7 local-sphere) 0.0 0.0 0.0 4096.0)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) v1-7)
+      )
+    (set! (-> s5-0 nav-radius) 8192.0)
+    (let ((v1-9 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-9 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-9 prim-core collide-with))
+      )
+    (set! (-> obj root-override2) s5-0)
+    )
+  0
+  (none)
+  )
+
+(defmethod coin-flip? spydroid ((obj spydroid))
+  "@returns The result of a 50/50 RNG roll"
+  #f
+  )
+
+(defmethod deactivate spydroid ((obj spydroid))
+  (if (nonzero? (-> obj explode-part))
+      (kill-and-free-particles (-> obj explode-part))
+      )
+  ((the-as (function process-focusable none) (find-parent-method spydroid 10)) obj)
+  (none)
+  )
+
+;; WARN: Return type mismatch nav-enemy vs spydroid.
+(defmethod relocate spydroid ((obj spydroid) (arg0 int))
+  (dotimes (v1-0 4)
+    (if (nonzero? (-> obj lightning v1-0))
+        (&+! (-> obj lightning v1-0) arg0)
+        )
+    )
+  (when (nonzero? (-> obj explode-part))
+    (if (nonzero? (-> obj explode-part))
+        (&+! (-> obj explode-part) arg0)
+        )
+    )
+  (the-as spydroid ((method-of-type nav-enemy relocate) obj arg0))
+  )
+
+(defmethod enemy-method-115 spydroid ((obj spydroid))
+  "@abstract"
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-spydroid" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (enemy-method-113 obj *spydroid-nav-enemy-info*)
+  (dotimes (s5-1 4)
+    (set! (-> obj lightning s5-1)
+          (new
+            'process
+            'lightning-control
+            (new 'static 'lightning-spec
+              :name #f
+              :flags (lightning-spec-flags lsf0)
+              :start-color (new 'static 'rgba :r #x80 :g #x80 :b #x80 :a #x80)
+              :end-color (new 'static 'rgba :r #x80 :g #x80 :b #x80 :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 8192.0
+              :merge-factor 0.5
+              :merge-count 2
+              :radius 512.0
+              :duration -1.0
+              :sound #f
+              )
+            obj
+            0.0
+            )
+          )
+    (let ((v1-10 (-> obj lightning s5-1))
+          (a0-5 0)
+          )
+      (let ((a1-5 (!= a0-5 (-> v1-10 state mode))))
+        (case a0-5
+          ((3)
+           (if a1-5
+               (set! (-> v1-10 state counter) 0.0)
+               )
+           )
+          ((1)
+           (set! (-> v1-10 state start-color) (-> v1-10 spec start-color))
+           (set! (-> v1-10 state end-color) (-> v1-10 spec end-color))
+           )
+          )
+        )
+      (set! (-> v1-10 state mode) (the-as lightning-mode a0-5))
+      )
+    )
+  (let ((v1-13 (-> obj neck)))
+    (set! (-> v1-13 up) (the-as uint 1))
+    (set! (-> v1-13 nose) (the-as uint 2))
+    (set! (-> v1-13 ear) (the-as uint 0))
+    (set-vector! (-> v1-13 twist-max) 3640.889 11832.889 0.0 1.0)
+    (set! (-> v1-13 ignore-angle) 15473.777)
+    )
+  (set-vector! (-> obj root-override2 scale) 0.5 0.5 0.5 1.0)
+  (let ((v1-17 (-> obj nav)))
+    (set! (-> v1-17 speed-scale) 1.0)
+    )
+  0
+  (set-gravity-length (-> obj root-override2 dynam) 573440.0)
+  (logior! (-> obj nav flags) (nav-control-flag momentum-ignore-heading))
+  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 709) obj))
+  (set! (-> obj explode-part) (create-launch-control (-> *part-group-id-table* 710) obj))
+  (add-connection *part-engine* obj 8 obj 3183 (new 'static 'vector :x -204.8 :y 122.88 :z 1720.32 :w 163840.0))
+  (add-connection
+    *part-engine*
+    obj
+    10
+    obj
+    3183
+    (new 'static 'vector :x -245.76 :y -122.88 :z 901.12 :w 163840.0)
+    )
+  (add-connection *part-engine* obj 4 obj 3184 (new 'static 'vector :x 819.2 :y -122.88 :z 3358.72 :w 163840.0))
+  (add-connection *part-engine* obj 6 obj 3185 (new 'static 'vector :w 163840.0))
+  (add-connection *part-engine* obj 6 obj 3186 (new 'static 'vector :w 163840.0))
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (logclear! (-> obj enemy-flags) (enemy-flag notice))
+  0
+  (none)
+  )
diff --git a/goal_src/jak2/levels/dig/dig3-obs.gc b/goal_src/jak2/levels/dig/dig3-obs.gc
index 0b0cc4d46d..21ee447f51 100644
--- a/goal_src/jak2/levels/dig/dig3-obs.gc
+++ b/goal_src/jak2/levels/dig/dig3-obs.gc
@@ -239,7 +239,7 @@
   )
 
 (deftype dig-spikey-step (process-drawable)
-  ((smush         smush-control :inline :offset-assert 208)
+  ((smush         smush-control :inline :offset-assert 200)
    (init-quat     quaternion    :inline :offset-assert 240)
    (shudder-angle float                 :offset-assert 256)
    (rot-angle     float                 :offset-assert 260)
@@ -276,26 +276,16 @@
           (suspend)
           )
         )
-      ((method-of-type smush-control activate!)
-       (the-as smush-control (&-> self stack 72))
-       -1.0
-       60
-       225
-       1.0
-       1.0
-       (-> self clock)
-       )
+      (activate! (-> self smush) -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))))
-                )
+          (set! (-> self shudder-angle) (* 364.0889 (update! (-> self smush))))
           (suspend)
           )
         )
       (set! (-> self shudder-angle) 0.0)
-      ((method-of-type smush-control set-zero!) (the-as smush-control (&-> self stack 72)))
+      (set-zero! (-> self smush))
       (let ((gp-4 (-> self clock frame-counter)))
         (until (>= (- (-> self clock frame-counter) gp-4) (seconds 0.25))
           (suspend)
diff --git a/goal_src/jak2/levels/drill_platform/ginsu.gc b/goal_src/jak2/levels/drill_platform/ginsu.gc
index 7ce462287c..4e26ef1fab 100644
--- a/goal_src/jak2/levels/drill_platform/ginsu.gc
+++ b/goal_src/jak2/levels/drill_platform/ginsu.gc
@@ -107,10 +107,10 @@
     )
   )
 
-(defskelgroup skel-ginsu ginsu ginsu-lod0-jg ginsu-idle-ja
-              ((ginsu-lod0-mg (meters 20)) (ginsu-lod1-mg (meters 40)) (ginsu-lod2-mg (meters 999999)))
+(defskelgroup skel-ginsu ginsu 0 5
+              ((1 (meters 20)) (2 (meters 40)) (3 (meters 999999)))
               :bounds (static-spherem 0 0 0 2.5)
-              :shadow ginsu-shadow-mg
+              :shadow 4
               :origin-joint-index 8
               )
 
@@ -134,20 +134,20 @@
 
 
 (deftype ginsu (nav-enemy)
-  ((blade-jm            joint-mod                :offset-assert 604)
-   (blade-speed         cam-float-seeker :inline :offset-assert 608)
-   (blade-angle         float                    :offset-assert 632)
-   (desired-distance    float                    :offset-assert 636)
-   (spiral-time         time-frame               :offset-assert 640)
-   (blade-part          part-spawner             :offset-assert 648)
-   (ambush-path         path-control             :offset-assert 652)
-   (path-pos            float                    :offset-assert 656)
-   (ambush-started      symbol                   :offset-assert 660)
-   (blade-sound         uint32                   :offset-assert 664)
-   (blade-sound-playing symbol                   :offset-assert 668)
-   (grind-sound         uint32                   :offset-assert 672)
-   (grind-sound-playing symbol                   :offset-assert 676)
-   (grind-timer         time-frame               :offset-assert 680)
+  ((blade-jm            joint-mod                        :offset-assert 604)
+   (blade-speed         cam-float-seeker         :inline :offset-assert 608)
+   (blade-angle         float                            :offset-assert 632)
+   (desired-distance    float                            :offset-assert 636)
+   (spiral-time         time-frame                       :offset-assert 640)
+   (blade-part          sparticle-launch-control         :offset-assert 648)
+   (ambush-path         path-control                     :offset-assert 652)
+   (path-pos            float                            :offset-assert 656)
+   (ambush-started      symbol                           :offset-assert 660)
+   (blade-sound         uint32                           :offset-assert 664)
+   (blade-sound-playing symbol                           :offset-assert 668)
+   (grind-sound         uint32                           :offset-assert 672)
+   (grind-sound-playing symbol                           :offset-assert 676)
+   (grind-timer         time-frame                       :offset-assert 680)
    )
   :heap-base #x230
   :method-count-assert 184
@@ -307,8 +307,8 @@
           (vector-negate! (the-as vector (-> s5-0 vector)) (the-as vector (-> s5-0 vector)))
           (set! (-> s5-0 vector 0 w) 0.0)
           )
+        (spawn-with-matrix (-> obj blade-part) s5-0)
         )
-      (run-logic? (-> obj blade-part))
       )
     )
   0
@@ -663,7 +663,7 @@
     0
     (set! (-> self state-time) (-> self clock frame-counter))
     (ja-channel-push! 1 (seconds 0.2))
-    (ja :group! ginsu-idle-ja :num! min)
+    (ja :group! (-> self draw art-group data 5) :num! min)
     (none)
     )
   :exit (behavior ()
@@ -736,7 +736,7 @@
       )
     0
     (set! (-> self state-time) (-> self clock frame-counter))
-    (ja :group! ginsu-attack-ja :num! min)
+    (ja :group! (-> self draw art-group data 15) :num! min)
     (none)
     )
   :exit (behavior ()
@@ -802,7 +802,7 @@
     (when (-> self ambush-started)
       (when (zero? (-> self skel active-channels))
         (ja-channel-push! 1 0)
-        (ja :group! ginsu-idle-ja :num! min)
+        (ja :group! (-> self draw art-group data 5) :num! min)
         )
       (vector-seek! (-> self root-override2 scale) (new 'static 'vector :x 1.0 :y 1.0 :z 1.0) 0.02)
       (+! (-> self path-pos) (/ 2048.0 (total-distance (-> self ambush-path))))
@@ -917,9 +917,11 @@
   )
 
 (defmethod deactivate ginsu ((obj ginsu))
-  (if (nonzero? (-> obj blade-part))
-      ((the-as (function none :behavior part-spawner) (method-of-object (-> obj blade-part) active)))
+  (when (nonzero? (-> obj blade-part))
+    (let ((a0-1 (-> obj blade-part)))
+      ((the-as (function sparticle-launch-control none) (method-of-object a0-1 kill-and-free-particles)) a0-1)
       )
+    )
   (if (-> obj blade-sound-playing)
       (sound-stop (the-as sound-id (-> obj blade-sound)))
       )
@@ -1072,7 +1074,7 @@
   (set! (-> obj blade-jm) (new 'process 'joint-mod (joint-mod-mode joint-set*) obj 8))
   (init (-> obj blade-speed) 1.0 0.01 0.1 0.9)
   (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 475) obj))
-  (set! (-> obj blade-part) (the-as part-spawner (create-launch-control (-> *part-group-id-table* 476) obj)))
+  (set! (-> obj blade-part) (create-launch-control (-> *part-group-id-table* 476) obj))
   (set! (-> obj ambush-path) (new 'process 'curve-control obj 'intro -1000000000.0))
   (set! (-> obj ambush-started) #f)
   (set! (-> obj path-pos) 0.0)
diff --git a/goal_src/jak2/levels/mars_tomb/widow-baron.gc b/goal_src/jak2/levels/mars_tomb/widow-baron.gc
index 8a8018aa81..7517d207cb 100644
--- a/goal_src/jak2/levels/mars_tomb/widow-baron.gc
+++ b/goal_src/jak2/levels/mars_tomb/widow-baron.gc
@@ -5,5 +5,1127 @@
 ;; name in dgo: widow-baron
 ;; dgos: TOA
 
+(declare-type baron-pod process-drawable)
+(declare-type tomb-boss-pillar process-drawable)
+
 ;; DECOMP BEGINS
 
+(deftype widow-float-seeker (structure)
+  ((target      float  :offset-assert   0)
+   (value       float  :offset-assert   4)
+   (vel         float  :offset-assert   8)
+   (accel       float  :offset-assert  12)
+   (max-vel     float  :offset-assert  16)
+   (max-partial float  :offset-assert  20)
+   (bounce-high float  :offset-assert  24)
+   )
+  :allow-misaligned
+  :method-count-assert 13
+  :size-assert         #x1c
+  :flag-assert         #xd0000001c
+  (:methods
+    (widow-float-seeker-method-9 (_type_ float float float float float) none 9)
+    (widow-float-seeker-method-10 (_type_ (pointer float)) none 10)
+    (widow-float-seeker-method-11 (_type_ float) none 11)
+    (widow-float-seeker-method-12 (_type_ float) none 12)
+    )
+  )
+
+
+(defmethod widow-float-seeker-method-9 widow-float-seeker ((obj widow-float-seeker) (arg0 float) (arg1 float) (arg2 float) (arg3 float) (arg4 float))
+  (set! (-> obj target) arg0)
+  (set! (-> obj value) arg0)
+  (set! (-> obj vel) 0.0)
+  (set! (-> obj accel) arg1)
+  (set! (-> obj max-vel) arg2)
+  (set! (-> obj max-partial) arg3)
+  (set! (-> obj bounce-high) arg4)
+  0
+  (none)
+  )
+
+(defmethod widow-float-seeker-method-10 widow-float-seeker ((obj widow-float-seeker) (arg0 (pointer float)))
+  (set! (-> obj target) (-> arg0 0))
+  (set! (-> obj value) (-> arg0 1))
+  (set! (-> obj vel) (-> arg0 2))
+  (set! (-> obj accel) (-> arg0 3))
+  (set! (-> obj max-vel) (-> arg0 4))
+  (set! (-> obj max-partial) (-> arg0 5))
+  (set! (-> obj bounce-high) (-> arg0 6))
+  0
+  (none)
+  )
+
+(defmethod widow-float-seeker-method-11 widow-float-seeker ((obj widow-float-seeker) (arg0 float))
+  (with-pp
+    0.0
+    0.0
+    (let* ((f1-2 (- (+ (-> obj target) arg0) (-> obj value)))
+           (f0-6 (if (= (-> obj target) 0.0)
+                     (* (-> obj max-partial) (fabs f1-2))
+                     (-> obj max-vel)
+                     )
+                 )
+           )
+      (let ((f1-3 (* f1-2 (* (-> obj accel) (-> pp clock time-adjust-ratio)))))
+        (+! (-> obj vel) f1-3)
+        )
+      (let ((f1-6 (fabs (-> obj vel)))
+            (f0-7 (fmin f0-6 (-> obj max-vel)))
+            )
+        (if (< f0-7 f1-6)
+            (set! (-> obj vel) (* (-> obj vel) (/ f0-7 f1-6)))
+            )
+        )
+      )
+    (let ((f0-11 (* (-> obj vel) (-> pp clock time-adjust-ratio))))
+      (+! (-> obj value) f0-11)
+      )
+    (when (and (!= (-> obj target) 0.0) (>= (-> obj value) (-> obj target)) (< 0.0 (-> obj vel)))
+      (set! (-> obj value) (-> obj target))
+      (set! (-> obj vel) (* (-> obj vel) (- (-> obj bounce-high))))
+      )
+    0
+    (none)
+    )
+  )
+
+(defmethod widow-float-seeker-method-12 widow-float-seeker ((obj widow-float-seeker) (arg0 float))
+  (set! (-> obj value) (+ (-> obj target) arg0))
+  (set! (-> obj vel) 0.0)
+  0
+  (none)
+  )
+
+(deftype widow-rand-vector (structure)
+  ((min-time int32          :offset-assert   0)
+   (max-time int32          :offset-assert   4)
+   (xz-max   float          :offset-assert   8)
+   (y-max    float          :offset-assert  12)
+   (timer    int32          :offset-assert  16)
+   (value    vector :inline :offset-assert  32)
+   )
+  :method-count-assert 11
+  :size-assert         #x30
+  :flag-assert         #xb00000030
+  (:methods
+    (init (_type_ int int float float) none 9)
+    (widow-rand-vector-method-10 (_type_) none 10)
+    )
+  )
+
+
+(defmethod init widow-rand-vector ((obj widow-rand-vector) (arg0 int) (arg1 int) (arg2 float) (arg3 float))
+  (set! (-> obj min-time) arg0)
+  (set! (-> obj max-time) arg1)
+  (set! (-> obj xz-max) (* 0.5 arg2))
+  (set! (-> obj y-max) (* 0.5 arg3))
+  (set! (-> obj timer) 0)
+  (vector-reset! (-> obj value))
+  0
+  (none)
+  )
+
+(defmethod widow-rand-vector-method-10 widow-rand-vector ((obj widow-rand-vector))
+  (with-pp
+    (set! (-> obj timer)
+          (- (the-as time-frame (-> obj timer)) (- (-> pp clock frame-counter) (-> pp clock old-frame-counter)))
+          )
+    (when (<= (-> obj timer) 0)
+      (set! (-> obj timer) (rand-vu-int-range (-> obj min-time) (-> obj max-time)))
+      (set! (-> obj value x) (rand-vu-float-range (- (-> obj xz-max)) (-> obj xz-max)))
+      (set! (-> obj value y) (rand-vu-float-range (- (-> obj y-max)) (-> obj y-max)))
+      (set! (-> obj value z) (rand-vu-float-range (- (-> obj xz-max)) (-> obj xz-max)))
+      )
+    0
+    (none)
+    )
+  )
+
+(deftype widow-oscillator (structure)
+  ((target  vector :inline :offset-assert   0)
+   (value   vector :inline :offset-assert  16)
+   (vel     vector :inline :offset-assert  32)
+   (accel   float          :offset-assert  48)
+   (max-vel float          :offset-assert  52)
+   (damping float          :offset-assert  56)
+   )
+  :method-count-assert 11
+  :size-assert         #x3c
+  :flag-assert         #xb0000003c
+  (:methods
+    (widow-oscillator-method-9 (_type_ vector float float float) none 9)
+    (widow-oscillator-method-10 (_type_ vector) none 10)
+    )
+  )
+
+
+(defmethod widow-oscillator-method-9 widow-oscillator ((obj widow-oscillator) (arg0 vector) (arg1 float) (arg2 float) (arg3 float))
+  (cond
+    (arg0
+      (set! (-> obj target quad) (-> arg0 quad))
+      (set! (-> obj value quad) (-> arg0 quad))
+      )
+    (else
+      (vector-reset! (-> obj target))
+      (vector-reset! (-> obj value))
+      )
+    )
+  (vector-reset! (-> obj vel))
+  (set! (-> obj accel) arg1)
+  (set! (-> obj max-vel) arg2)
+  (set! (-> obj damping) arg3)
+  0
+  (none)
+  )
+
+(defmethod widow-oscillator-method-10 widow-oscillator ((obj widow-oscillator) (arg0 vector))
+  (with-pp
+    (let ((gp-0 (new 'stack-no-clear 'vector)))
+      (let ((f30-0 (fmax (-> obj max-vel) (vector-length (-> obj vel)))))
+        (cond
+          (arg0
+            (vector+! gp-0 (-> obj target) arg0)
+            (vector-! gp-0 gp-0 (-> obj value))
+            )
+          (else
+            (vector-! gp-0 (-> obj target) (-> obj value))
+            )
+          )
+        (vector-normalize! gp-0 (* (-> obj accel) (-> pp clock time-adjust-ratio)))
+        (vector+! (-> obj vel) (-> obj vel) gp-0)
+        (let ((f0-3 (vector-length (-> obj vel))))
+          (if (< f30-0 f0-3)
+              (vector-float*! (-> obj vel) (-> obj vel) (/ f30-0 f0-3))
+              )
+          )
+        )
+      (vector-float*! (-> obj vel) (-> obj vel) (-> obj damping))
+      (vector-float*! gp-0 (-> obj vel) (-> pp clock time-adjust-ratio))
+      (vector+! (-> obj value) (-> obj value) gp-0)
+      )
+    0
+    (none)
+    )
+  )
+
+(defskelgroup skel-widow widow widow-lod0-jg 8
+              ((widow-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 12)
+              :shadow widow-shadow-mg
+              :origin-joint-index 3
+              )
+
+(deftype widow-shot (guard-shot)
+  ()
+  :heap-base #x170
+  :method-count-assert 40
+  :size-assert         #x1f0
+  :flag-assert         #x28017001f0
+  )
+
+
+(deftype widow (process-drawable)
+  ((bomb                         handle                   8       :offset-assert 200)
+   (next-launch                  int32                            :offset-assert 264)
+   (launch-dest                  vector                   :inline :offset-assert 272)
+   (next-jumper                  int32                            :offset-assert 288)
+   (ammos                        handle                   2       :offset-assert 296)
+   (ammo-timers                  time-frame               2       :offset-assert 312)
+   (bomb-hits                    int32                            :offset-assert 328)
+   (circle-center                vector                   :inline :offset-assert 336)
+   (theta                        cam-float-seeker         :inline :offset-assert 352)
+   (traj                         trajectory               :inline :offset-assert 384)
+   (osc                          widow-oscillator         :inline :offset-assert 432)
+   (noise-osc                    widow-oscillator         :inline :offset-assert 496)
+   (rand-vec                     widow-rand-vector        :inline :offset-assert 560)
+   (attack-from-high-deg         symbol                           :offset-assert 608)
+   (which-gun                    int32                            :offset-assert 612)
+   (which-pod                    int32                            :offset-assert 616)
+   (left-cover-angle             widow-float-seeker       :inline :offset        620)
+   (right-cover-angle            widow-float-seeker       :inline :offset        648)
+   (left-cover-jm                joint-mod                        :offset-assert 676)
+   (right-cover-jm               joint-mod                        :offset-assert 680)
+   (drill-speed                  cam-float-seeker         :inline :offset-assert 684)
+   (drill-angle                  float                            :offset-assert 708)
+   (left-drill-jm                joint-mod                        :offset-assert 712)
+   (right-drill-jm               joint-mod                        :offset-assert 716)
+   (flying                       symbol                           :offset-assert 720)
+   (previous-anim                int32                            :offset-assert 724)
+   (launched-a-bomb              symbol                           :offset-assert 728)
+   (old-bomb-hits                int32                            :offset-assert 732)
+   (catwalk                      handle                   8       :offset-assert 736)
+   (heart                        handle                           :offset-assert 800)
+   (pod                          handle                           :offset-assert 808)
+   (baron                        (pointer manipy)                 :offset-assert 816)
+   (drill-spark-part             sparticle-launch-control         :offset-assert 820)
+   (drill-spark-part-alt         sparticle-launch-control         :offset-assert 824)
+   (extract-stone-time           time-frame                       :offset-assert 832)
+   (extract-stone-part           sparticle-launch-control         :offset-assert 840)
+   (insert-stone-time            time-frame                       :offset-assert 848)
+   (insert-stone-part            sparticle-launch-control         :offset-assert 856)
+   (land-part                    sparticle-launch-control         :offset-assert 860)
+   (green-charge-part            sparticle-launch-control         :offset-assert 864)
+   (green-fire-part              sparticle-launch-control         :offset-assert 868)
+   (lightning                    lightning-control        5       :offset-assert 872)
+   (stop-catwalk-sound           symbol                           :offset-assert 892)
+   (catwalk-sound                uint32                           :offset-assert 896)
+   (drill-sound                  uint32                           :offset-assert 900)
+   (drill-sound-playing          symbol                           :offset-assert 904)
+   (drill-sweeten-sound          uint32                           :offset-assert 908)
+   (drill-sweeten-sound-playing  symbol                           :offset-assert 912)
+   (movie-handle                 handle                           :offset-assert 920)
+   (tilt                         cam-float-seeker         :inline :offset-assert 928)
+   (targetted-catwalk            int32                            :offset-assert 952)
+   (hover-sound                  uint32                           :offset-assert 956)
+   (hover-sound-playing          symbol                           :offset-assert 960)
+   (shake-sound                  uint32                           :offset-assert 964)
+   (shake-sound-playing          symbol                           :offset-assert 968)
+   (hud                          handle                           :offset-assert 976)
+   (last-want-stone-talker       int8                             :offset-assert 984)
+   (last-general-flying-talker   int8                             :offset-assert 985)
+   (last-launch-droids-talker    int8                             :offset-assert 986)
+   (last-launch-bombs-talker     int8                             :offset-assert 987)
+   (last-shoot-gun-talker        int8                             :offset-assert 988)
+   (last-stone-charge-up-talker  int8                             :offset-assert 989)
+   (last-after-stone-shot-talker int8                             :offset-assert 990)
+   (last-leave-perch-talker      int8                             :offset-assert 991)
+   (last-damaged-talker          int8                             :offset-assert 992)
+   (kicked-bombs                 int8                             :offset-assert 993)
+   (launch-stages-completed      int8                             :offset-assert 994)
+   (current-shoot-stage          int16                            :offset-assert 996)
+   (last-gun-hit-stage           int16                            :offset-assert 998)
+   (gun-hits                     int16                            :offset-assert 1000)
+   (last-attack-id               uint32                           :offset-assert 1004)
+   )
+  :heap-base #x370
+  :method-count-assert 47
+  :size-assert         #x3f0
+  :flag-assert         #x2f037003f0
+  (:methods
+    (beaten () _type_ :state 20)
+    (kaboom () _type_ :state 21)
+    (hover-low-stage-3 () _type_ :state 22)
+    (hover-shooting-stage-3 () _type_ :state 23)
+    (hover-launch-bombs-stage-3 () _type_ :state 24)
+    (hover-big-blast-stage-3 () _type_ :state 25)
+    (hover-rise-stage-3 () _type_ :state 26)
+    (hover-jump-down-stage-3 () _type_ :state 27)
+    (big-reaction-stage-2 () _type_ :state 28)
+    (watch-bombs-stage-2 () _type_ :state 29)
+    (launch-bombs-stage-2 () _type_ :state 30)
+    (back-to-perch-stage-2 () _type_ :state 31)
+    (hover-low-stage-2 () _type_ :state 32)
+    (hover-shooting-stage-2 () _type_ :state 33)
+    (hover-rise-stage-2 () _type_ :state 34)
+    (hover-seek-under-stage-2 () _type_ :state 35)
+    (hover-jump-down-stage-2 () _type_ :state 36)
+    (launch-droids-stage-2 () _type_ :state 37)
+    (big-reaction-stage-1 () _type_ :state 38)
+    (watch-bombs-stage-1 () _type_ :state 39)
+    (launch-bombs-stage-1 () _type_ :state 40)
+    (watch-droids-stage-1 () _type_ :state 41)
+    (launch-droids-stage-1 () _type_ :state 42)
+    (hidden () _type_ :state 43)
+    (widow-method-44 (_type_ vector vector) symbol 44)
+    (widow-method-45 (_type_ vector vector vector) none 45)
+    (widow-method-46 (_type_ vector int) none 46)
+    )
+  )
+
+
+(deftype baron-pod (process-drawable)
+  ((red-tip-change-time time-frame  :offset-assert 200)
+   (alt-red-tip-on      symbol      :offset-assert 208)
+   (blink-time          time-frame  :offset-assert 216)
+   (blink-mask          int32       :offset-assert 224)
+   (has-stone           symbol      :offset-assert 228)
+   )
+  :heap-base #x70
+  :method-count-assert 22
+  :size-assert         #xe8
+  :flag-assert         #x16007000e8
+  (:methods
+    (idle () _type_ :state 20)
+    (baron-pod-method-21 (_type_ symbol) none 21)
+    )
+  )
+
+
+(defskelgroup skel-baron-pod baron-pod baron-pod-lod0-jg baron-pod-idle-ja
+              ((baron-pod-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 3)
+              :shadow baron-pod-shadow-mg
+              :origin-joint-index 3
+              )
+
+(defmethod baron-pod-method-21 baron-pod ((obj baron-pod) (arg0 symbol))
+  (with-pp
+    (when (>= (- (-> pp clock frame-counter) (-> obj red-tip-change-time)) 0)
+      (set! (-> obj alt-red-tip-on) (not (-> obj alt-red-tip-on)))
+      (set! (-> obj red-tip-change-time) (+ (-> pp clock frame-counter) (seconds 0.5)))
+      (set! arg0 #t)
+      )
+    (when (>= (- (-> pp clock frame-counter) (-> obj blink-time)) 0)
+      (set! (-> obj blink-mask) 0)
+      (dotimes (s5-0 10)
+        (let* ((f30-0 0.5)
+               (v1-17 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+               (v1-18 (the-as number (logior #x3f800000 v1-17)))
+               )
+          (if (< f30-0 (+ -1.0 (the-as float v1-18)))
+              (logior! (-> obj blink-mask) (ash 1 s5-0))
+              )
+          )
+        )
+      (set! (-> obj blink-time) (+ (-> pp clock frame-counter) (the int (* 300.0 (rand-vu-float-range 0.25 0.75)))))
+      (set! arg0 #t)
+      )
+    (when arg0
+      (remove-from-process *part-engine* obj)
+      (add-connection *part-engine* obj 13 obj 3264 (new 'static 'vector :w 819200.0))
+      (add-connection *part-engine* obj 14 obj 3264 (new 'static 'vector :w 819200.0))
+      (if (-> obj alt-red-tip-on)
+          (add-connection *part-engine* obj 5 obj 3251 (new 'static 'vector :w 819200.0))
+          (add-connection *part-engine* obj 6 obj 3251 (new 'static 'vector :w 819200.0))
+          )
+      (let ((s5-2 (-> obj blink-mask)))
+        (if (logtest? s5-2 1)
+            (add-connection *part-engine* obj 8 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        (if (logtest? s5-2 2)
+            (add-connection *part-engine* obj 9 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        (if (logtest? s5-2 4)
+            (add-connection *part-engine* obj 10 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        (if (logtest? s5-2 8)
+            (add-connection *part-engine* obj 11 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        (if (logtest? s5-2 16)
+            (add-connection *part-engine* obj 12 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        (if (logtest? s5-2 32)
+            (add-connection *part-engine* obj 15 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        (if (logtest? s5-2 64)
+            (add-connection *part-engine* obj 16 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        (if (logtest? s5-2 128)
+            (add-connection *part-engine* obj 17 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        (if (logtest? s5-2 256)
+            (add-connection *part-engine* obj 18 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        (if (logtest? s5-2 512)
+            (add-connection *part-engine* obj 19 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        )
+      (cond
+        ((-> obj has-stone)
+         (add-connection *part-engine* obj 4 obj 3258 (new 'static 'vector :y 4096.0 :w 819200.0))
+         (add-connection *part-engine* obj 4 obj 3259 (new 'static 'vector :y 4096.0 :w 819200.0))
+         )
+        (else
+          (add-connection *part-engine* obj 4 obj 3256 (new 'static 'vector :y 4096.0 :w 819200.0))
+          (add-connection *part-engine* obj 4 obj 3257 (new 'static 'vector :y 4096.0 :w 819200.0))
+          )
+        )
+      )
+    (if (-> obj has-stone)
+        (spawn (-> obj part) (-> obj root trans))
+        )
+    0
+    (none)
+    )
+  )
+
+(defstate idle (baron-pod)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as object (case event-type
+                     (('frame)
+                      (let ((v1-3 (ja-group)))
+                        (when (not (and v1-3 (= v1-3 (-> self draw art-group data 4))))
+                          (ja :group! (-> self draw art-group data 4) :num! min)
+                          (set! (-> self draw bounds w) 81920.0)
+                          )
+                        )
+                      (when (and (< (ja-aframe-num 0) 834.0) (>= (the-as float (-> event param 0)) 834.0))
+                        (setup-masks (-> self draw) 4 2)
+                        (set! (-> self has-stone) #t)
+                        (the-as symbol (baron-pod-method-21 self #t))
+                        )
+                      )
+                     (('finale)
+                      (the-as symbol (setup-masks (-> self draw) 8 0))
+                      )
+                     )
+            )
+    )
+  :trans (behavior ()
+    (baron-pod-method-21 self #f)
+    (none)
+    )
+  :code (the-as (function none :behavior baron-pod) sleep-code)
+  :post (the-as (function none :behavior baron-pod) transform-post)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior baron-pod-init-by-other baron-pod ((arg0 vector))
+  (let ((s5-0 (new 'process 'collide-shape-moving self (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)
+          )
+    (set! (-> s5-0 penetrated-by) (the-as penetrate -1))
+    (let ((v1-7 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-7 transform-index) 3)
+      (set-vector! (-> v1-7 local-sphere) 0.0 0.0 9216.0 4096.0)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) v1-7)
+      )
+    (set! (-> s5-0 nav-radius) 8192.0)
+    (let ((v1-9 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-9 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-9 prim-core collide-with))
+      )
+    (set! (-> self root) s5-0)
+    )
+  (set! (-> self root trans quad) (-> arg0 quad))
+  (initialize-skeleton
+    self
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-baron-pod" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (setup-masks (-> self draw) 0 12)
+  (set! (-> self root pause-adjust-distance) 245760.0)
+  (let ((v1-21 (-> self node-list data)))
+    (set! (-> v1-21 0 param0) (the-as (function cspace transformq none) cspace<-parent-joint!))
+    (set! (-> v1-21 0 param1) (the-as basic (-> self parent)))
+    (set! (-> v1-21 0 param2) (the-as basic 3))
+    )
+  (set! (-> self blink-time) 0)
+  (set! (-> self red-tip-change-time) 0)
+  (set! (-> self has-stone) #f)
+  (set! (-> self part) (create-launch-control (-> *part-group-id-table* 728) self))
+  (baron-pod-method-21 self #t)
+  (go-virtual idle)
+  (none)
+  )
+
+(deftype tomb-boss-bridge (process-drawable)
+  ()
+  :heap-base #x50
+  :method-count-assert 21
+  :size-assert         #xc8
+  :flag-assert         #x15005000c8
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+
+(defstate idle (tomb-boss-bridge)
+  :virtual #t
+  :trans (behavior ()
+    (when (task-node-closed? (game-task-node tomb-boss-introduction))
+      (cleanup-for-death self)
+      (deactivate self)
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior tomb-boss-bridge) sleep-code)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! tomb-boss-bridge ((obj tomb-boss-bridge) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (case ((method-of-type res-lump get-property-struct)
+         (-> obj entity)
+         'tomb-boss-bridge-type
+         'interp
+         -1000000000.0
+         (the-as structure 'a)
+         (the-as (pointer res-tag) #f)
+         *res-static-buf*
+         )
+    (('b)
+     (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-tomb-boss-bridge-b" (the-as (pointer uint32) #f)))
+       (the-as pair 0)
+       )
+     )
+    (else
+      (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-tomb-boss-bridge-a" (the-as (pointer uint32) #f)))
+        (the-as pair 0)
+        )
+      )
+    )
+  (set! (-> obj draw light-index) (the-as uint 2))
+  (ja-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(defbehavior widow-want-stone-talker widow ()
+  (if (or (>= (-> self bomb-hits) 4) (let* ((f30-0 0.001)
+                                            (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                                            (v1-5 (the-as number (logior #x3f800000 v1-4)))
+                                            )
+                                       (< f30-0 (+ -1.0 (the-as float v1-5)))
+                                       )
+          )
+      (return (the-as int #f))
+      )
+  (let ((v1-9 (rand-vu-int-count 5)))
+    (if (>= v1-9 (-> self last-want-stone-talker))
+        (+! v1-9 1)
+        )
+    (set! (-> self last-want-stone-talker) v1-9)
+    (cond
+      ((zero? v1-9)
+       (talker-spawn-func (-> *talker-speech* 241) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 1)
+       (talker-spawn-func (-> *talker-speech* 242) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 2)
+       (talker-spawn-func (-> *talker-speech* 243) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 3)
+       (talker-spawn-func (-> *talker-speech* 244) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 4)
+       (talker-spawn-func (-> *talker-speech* 245) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 5)
+       (talker-spawn-func (-> *talker-speech* 246) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      )
+    )
+  )
+
+(defbehavior widow-general-flying-talker widow ()
+  (if (or (>= (-> self bomb-hits) 4) (let* ((f30-0 0.002)
+                                            (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                                            (v1-5 (the-as number (logior #x3f800000 v1-4)))
+                                            )
+                                       (< f30-0 (+ -1.0 (the-as float v1-5)))
+                                       )
+          )
+      (return (the-as int #f))
+      )
+  (let ((v1-9 (rand-vu-int-count 4)))
+    (if (>= v1-9 (-> self last-general-flying-talker))
+        (+! v1-9 1)
+        )
+    (set! (-> self last-general-flying-talker) v1-9)
+    (cond
+      ((zero? v1-9)
+       (talker-spawn-func (-> *talker-speech* 273) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 1)
+       (talker-spawn-func (-> *talker-speech* 288) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 2)
+       (talker-spawn-func (-> *talker-speech* 289) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 3)
+       (talker-spawn-func (-> *talker-speech* 290) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 4)
+       (talker-spawn-func (-> *talker-speech* 291) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      )
+    )
+  )
+
+(defbehavior widow-launch-droids-talker widow ()
+  (if (or (>= (-> self bomb-hits) 4) (let* ((f30-0 0.9)
+                                            (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                                            (v1-5 (the-as number (logior #x3f800000 v1-4)))
+                                            )
+                                       (< f30-0 (+ -1.0 (the-as float v1-5)))
+                                       )
+          )
+      (return (the-as int #f))
+      )
+  (let ((v1-9 (rand-vu-int-count 4)))
+    (if (>= v1-9 (-> self last-launch-droids-talker))
+        (+! v1-9 1)
+        )
+    (set! (-> self last-launch-droids-talker) v1-9)
+    (cond
+      ((zero? v1-9)
+       (talker-spawn-func (-> *talker-speech* 247) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 1)
+       (talker-spawn-func (-> *talker-speech* 248) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 2)
+       (talker-spawn-func (-> *talker-speech* 249) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 3)
+       (talker-spawn-func (-> *talker-speech* 250) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 4)
+       (talker-spawn-func (-> *talker-speech* 299) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      )
+    )
+  )
+
+(defbehavior widow-launch-bombs-talker widow ()
+  (if (or (>= (-> self bomb-hits) 4) (let* ((f30-0 0.9)
+                                            (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                                            (v1-5 (the-as number (logior #x3f800000 v1-4)))
+                                            )
+                                       (< f30-0 (+ -1.0 (the-as float v1-5)))
+                                       )
+          )
+      (return (the-as int #f))
+      )
+  (let ((v1-9 (rand-vu-int-count 5)))
+    (if (>= v1-9 (-> self last-launch-bombs-talker))
+        (+! v1-9 1)
+        )
+    (set! (-> self last-launch-bombs-talker) v1-9)
+    (cond
+      ((zero? v1-9)
+       (talker-spawn-func (-> *talker-speech* 251) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 1)
+       (talker-spawn-func (-> *talker-speech* 252) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 2)
+       (talker-spawn-func (-> *talker-speech* 255) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 3)
+       (talker-spawn-func (-> *talker-speech* 256) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 4)
+       (talker-spawn-func (-> *talker-speech* 267) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 5)
+       (talker-spawn-func (-> *talker-speech* 272) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      )
+    )
+  )
+
+(defbehavior widow-shoot-gun-talker widow ()
+  (if (or (>= (-> self bomb-hits) 4) (let* ((f30-0 0.7)
+                                            (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                                            (v1-5 (the-as number (logior #x3f800000 v1-4)))
+                                            )
+                                       (< f30-0 (+ -1.0 (the-as float v1-5)))
+                                       )
+          )
+      (return (the-as int #f))
+      )
+  (let ((v1-9 (rand-vu-int-count 10)))
+    (if (>= v1-9 (-> self last-shoot-gun-talker))
+        (+! v1-9 1)
+        )
+    (set! (-> self last-shoot-gun-talker) v1-9)
+    (cond
+      ((zero? v1-9)
+       (talker-spawn-func (-> *talker-speech* 253) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 1)
+       (talker-spawn-func (-> *talker-speech* 254) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 2)
+       (talker-spawn-func (-> *talker-speech* 257) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 3)
+       (talker-spawn-func (-> *talker-speech* 258) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 4)
+       (talker-spawn-func (-> *talker-speech* 286) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 5)
+       (talker-spawn-func (-> *talker-speech* 268) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 6)
+       (talker-spawn-func (-> *talker-speech* 269) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 7)
+       (talker-spawn-func (-> *talker-speech* 292) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 8)
+       (talker-spawn-func (-> *talker-speech* 293) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 9)
+       (talker-spawn-func (-> *talker-speech* 300) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 10)
+       (talker-spawn-func (-> *talker-speech* 274) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      )
+    )
+  )
+
+(defbehavior widow-stone-charge-up-talker widow ()
+  (if (or (>= (-> self bomb-hits) 4) (let* ((f30-0 0.6)
+                                            (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                                            (v1-5 (the-as number (logior #x3f800000 v1-4)))
+                                            )
+                                       (< f30-0 (+ -1.0 (the-as float v1-5)))
+                                       )
+          )
+      (return (the-as int #f))
+      )
+  (let ((v1-9 (rand-vu-int-count 5)))
+    (if (>= v1-9 (-> self last-stone-charge-up-talker))
+        (+! v1-9 1)
+        )
+    (set! (-> self last-stone-charge-up-talker) v1-9)
+    (cond
+      ((zero? v1-9)
+       (talker-spawn-func (-> *talker-speech* 259) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 1)
+       (talker-spawn-func (-> *talker-speech* 260) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 2)
+       (talker-spawn-func (-> *talker-speech* 264) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 3)
+       (talker-spawn-func (-> *talker-speech* 296) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 4)
+       (talker-spawn-func (-> *talker-speech* 298) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 5)
+       (talker-spawn-func (-> *talker-speech* 266) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      )
+    )
+  )
+
+(defbehavior widow-after-stone-shot-talker widow ()
+  (if (or (>= (-> self bomb-hits) 4) (let* ((f30-0 0.6)
+                                            (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                                            (v1-5 (the-as number (logior #x3f800000 v1-4)))
+                                            )
+                                       (< f30-0 (+ -1.0 (the-as float v1-5)))
+                                       )
+          )
+      (return (the-as int #f))
+      )
+  (let ((v1-9 (rand-vu-int-count 5)))
+    (if (>= v1-9 (-> self last-after-stone-shot-talker))
+        (+! v1-9 1)
+        )
+    (set! (-> self last-after-stone-shot-talker) v1-9)
+    (cond
+      ((zero? v1-9)
+       (talker-spawn-func (-> *talker-speech* 261) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 1)
+       (talker-spawn-func (-> *talker-speech* 262) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 2)
+       (talker-spawn-func (-> *talker-speech* 263) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 3)
+       (talker-spawn-func (-> *talker-speech* 297) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 4)
+       (talker-spawn-func (-> *talker-speech* 271) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 5)
+       (talker-spawn-func (-> *talker-speech* 265) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      )
+    )
+  )
+
+(defbehavior widow-leave-perch-talker widow ()
+  (if (or (>= (-> self bomb-hits) 4) (let* ((f30-0 0.4)
+                                            (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                                            (v1-5 (the-as number (logior #x3f800000 v1-4)))
+                                            )
+                                       (< f30-0 (+ -1.0 (the-as float v1-5)))
+                                       )
+          )
+      (return (the-as int #f))
+      )
+  (let ((v1-9 (rand-vu-int-count 4)))
+    (if (>= v1-9 (-> self last-leave-perch-talker))
+        (+! v1-9 1)
+        )
+    (set! (-> self last-leave-perch-talker) v1-9)
+    (cond
+      ((zero? v1-9)
+       (talker-spawn-func (-> *talker-speech* 270) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 1)
+       (talker-spawn-func (-> *talker-speech* 277) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 2)
+       (talker-spawn-func (-> *talker-speech* 275) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 3)
+       (talker-spawn-func (-> *talker-speech* 276) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 4)
+       (talker-spawn-func (-> *talker-speech* 285) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      )
+    )
+  )
+
+(defbehavior widow-damaged-talker widow ()
+  (let* ((f30-0 0.99)
+         (v1-2 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+         (v1-3 (the-as number (logior #x3f800000 v1-2)))
+         )
+    (if (< f30-0 (+ -1.0 (the-as float v1-3)))
+        (return (the-as int #f))
+        )
+    )
+  (let ((v1-7 (rand-vu-int-count 11)))
+    (if (>= v1-7 (-> self last-damaged-talker))
+        (+! v1-7 1)
+        )
+    (set! (-> self last-damaged-talker) v1-7)
+    (cond
+      ((zero? v1-7)
+       (talker-spawn-func (-> *talker-speech* 278) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 1)
+       (talker-spawn-func (-> *talker-speech* 279) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 2)
+       (talker-spawn-func (-> *talker-speech* 280) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 3)
+       (talker-spawn-func (-> *talker-speech* 281) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 4)
+       (talker-spawn-func (-> *talker-speech* 282) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 5)
+       (talker-spawn-func (-> *talker-speech* 283) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 6)
+       (talker-spawn-func (-> *talker-speech* 284) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 7)
+       (talker-spawn-func (-> *talker-speech* 294) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 8)
+       (talker-spawn-func (-> *talker-speech* 295) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 9)
+       (talker-spawn-func (-> *talker-speech* 287) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 10)
+       (talker-spawn-func (-> *talker-speech* 307) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 11)
+       (talker-spawn-func (-> *talker-speech* 304) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      )
+    )
+  )
+
+;; WARN: Return type mismatch none vs object.
+(defbehavior widow-handler widow ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (local-vars (v0-0 object) (sv-224 symbol) (sv-240 symbol) (sv-256 vector) (sv-272 matrix))
+  (the-as
+    object
+    (case arg2
+      (('attack)
+       (let ((v1-1 (the-as object (-> arg3 param 1))))
+         (when (and (logtest? (attack-info-mask penetrate-using) (-> (the-as attack-info v1-1) mask))
+                    (logtest? (penetrate dark-bomb) (-> (the-as attack-info v1-1) penetrate-using))
+                    (!= (-> self last-attack-id) (-> (the-as attack-info v1-1) id))
+                    )
+           (set! (-> self last-attack-id) (-> (the-as attack-info v1-1) id))
+           (send-event self 'bomb-hit (target-pos 0) 4)
+           (let ((gp-2 (get-process *default-dead-pool* part-tracker #x4000)))
+             (when gp-2
+               (let ((t9-3 (method-of-type part-tracker activate)))
+                 (t9-3
+                   (the-as part-tracker gp-2)
+                   *entity-pool*
+                   (symbol->string (-> part-tracker symbol))
+                   (the-as pointer #x70004000)
+                   )
+                 )
+               (let ((s5-0 run-function-in-process)
+                     (s4-0 gp-2)
+                     (s3-0 part-tracker-init)
+                     (s2-0 (-> *part-group-id-table* 710))
+                     (s1-0 600)
+                     (s0-0 #f)
+                     )
+                 (set! sv-224 (the-as symbol #f))
+                 (set! sv-240 (the-as symbol #f))
+                 (set! sv-272 *launch-matrix*)
+                 (set! sv-256 (-> sv-272 trans))
+                 (let ((v1-16 (-> (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 11)) quad)))
+                   (set! (-> sv-256 quad) v1-16)
+                   )
+                 ((the-as (function object object object object object object object object none) s5-0)
+                  s4-0
+                  s3-0
+                  s2-0
+                  s1-0
+                  s0-0
+                  sv-224
+                  sv-240
+                  sv-272
+                  )
+                 )
+               (-> gp-2 ppointer)
+               )
+             )
+           )
+         )
+       )
+      (('shot-hit-target)
+       (when (< (-> self last-gun-hit-stage) (-> self current-shoot-stage))
+         (+! (-> self gun-hits) 1)
+         (set! v0-0 (-> self current-shoot-stage))
+         (set! (-> self last-gun-hit-stage) (the-as int v0-0))
+         v0-0
+         )
+       )
+      (('bomb-kicked)
+       (set! v0-0 (+ (-> self kicked-bombs) 1))
+       (set! (-> self kicked-bombs) (the-as int v0-0))
+       v0-0
+       )
+      (('widow-get-center)
+       (-> self circle-center)
+       )
+      (('debris-hit)
+       (when (< -819.2 (-> self osc vel y))
+         (sound-play "wid-debris-hit")
+         (case (-> arg3 param 0)
+           ((1)
+            (set! (-> self osc vel y) (+ -3072.0 (-> self osc vel y)))
+            )
+           ((2)
+            (set! (-> self osc vel y) (+ -2048.0 (-> self osc vel y)))
+            )
+           )
+         )
+       )
+      (('catwalk-hit)
+       (let ((v1-26 (-> arg3 param 0)))
+         (when (and (> (the-as int v1-26) 0) (< (the-as int v1-26) 8))
+           (let ((v1-28 (new 'stack-no-clear 'event-message-block)))
+             (set! (-> v1-28 from) (process->ppointer arg0))
+             (set! (-> v1-28 num-params) arg1)
+             (set! (-> v1-28 message) arg2)
+             (set! (-> v1-28 param 0) (-> arg3 param 0))
+             (set! (-> v1-28 param 1) (-> arg3 param 1))
+             (set! (-> v1-28 param 2) (-> arg3 param 2))
+             (set! (-> v1-28 param 3) (-> arg3 param 3))
+             (set! (-> v1-28 param 4) (-> arg3 param 4))
+             (set! (-> v1-28 param 5) (-> arg3 param 5))
+             (send-event-function (handle->process (-> self catwalk 0)) v1-28)
+             )
+           )
+         )
+       )
+      (('child-jumped)
+       (set! v0-0 (logclear (-> (the-as spydroid arg0) enemy-flags) (enemy-flag alert)))
+       (set! (-> (the-as spydroid arg0) enemy-flags) (the-as enemy-flag v0-0))
+       v0-0
+       )
+      (('bomb-hit)
+       (set! (-> self bomb-hits) (min 4 (+ (-> self bomb-hits) (-> arg3 param 1))))
+       (let ((v1-33 (handle->process (-> self hud))))
+         (if v1-33
+             (set! (-> (the-as hud-widow v1-33) values 1 target) (/ (* 100 (- 4 (-> self bomb-hits))) 4))
+             )
+         )
+       (when (and (not (-> self flying)) (< (-> self bomb-hits) 4))
+         (let* ((s4-2 (-> arg3 param 0))
+                (v0-9 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 3)))
+                (s5-2 (-> self node-list data 3 bone transform))
+                (s4-3 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) (the-as vector s4-2) v0-9) 1.0))
+                (f30-0 (vector-dot s4-3 (vector-normalize-copy! (new 'stack-no-clear 'vector) (-> s5-2 vector 2) 1.0)))
+                (f28-0
+                  (vector-dot s4-3 (vector-normalize-copy! (new 'stack-no-clear 'vector) (the-as vector (-> s5-2 vector)) 1.0))
+                  )
+                )
+           (ja-channel-push! 1 (seconds 0.03))
+           (set! (-> self drill-speed target) 0.0)
+           (cond
+             ((< (cos 5461.3335) f30-0)
+              (ja :group! (-> self draw art-group data 25) :num! min)
+              (setup-masks (-> self draw) 2 128)
+              )
+             ((and (< (cos 8192.0) f30-0) (< 0.0 f28-0))
+              (ja :group! (-> self draw art-group data 26) :num! min)
+              (setup-masks (-> self draw) 4 256)
+              )
+             ((< (cos 8192.0) f30-0)
+              (ja :group! (-> self draw art-group data 27) :num! min)
+              (setup-masks (-> self draw) 8 512)
+              )
+             ((< 0.0 f28-0)
+              (ja :group! (-> self draw art-group data 23) :num! min)
+              (setup-masks (-> self draw) 16 1024)
+              )
+             (else
+               (ja :group! (-> self draw art-group data 24) :num! min)
+               (setup-masks (-> self draw) 32 2048)
+               )
+             )
+           )
+         )
+       (when (-> self flying)
+         (set! (-> self drill-speed target) 0.0)
+         (cond
+           ((>= (-> self bomb-hits) 4)
+            #f
+            )
+           ((begin
+              (ja-channel-push! 1 (seconds 0.03))
+              (let* ((gp-3 (-> arg3 param 0))
+                     (v0-28 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 3)))
+                     (s5-8 (-> self node-list data 3 bone transform))
+                     (f0-20 (vector-dot
+                              (vector-normalize! (vector-! (new 'stack-no-clear 'vector) (the-as vector gp-3) v0-28) 1.0)
+                              (vector-normalize-copy! (new 'stack-no-clear 'vector) (the-as vector (-> s5-8 vector)) 1.0)
+                              )
+                            )
+                     )
+                (< 0.0 f0-20)
+                )
+              )
+            (ja :group! (-> self draw art-group data 37) :num! min)
+            (the-as object (setup-masks (-> self draw) 16 1024))
+            )
+           (else
+             (ja :group! (-> self draw art-group data 36) :num! min)
+             (the-as object (setup-masks (-> self draw) 32 2048))
+             )
+           )
+         )
+       )
+      )
+    )
+  )
diff --git a/goal_src/jak2/levels/mars_tomb/widow-extras.gc b/goal_src/jak2/levels/mars_tomb/widow-extras.gc
index f2e15e9355..d4d506d9bd 100644
--- a/goal_src/jak2/levels/mars_tomb/widow-extras.gc
+++ b/goal_src/jak2/levels/mars_tomb/widow-extras.gc
@@ -7,3 +7,1989 @@
 
 ;; DECOMP BEGINS
 
+(deftype tomb-boss-catwalk (process-drawable)
+  ((root-override collide-shape-moving  :offset        128)
+   (which-look    int32                 :offset-assert 200)
+   )
+  :heap-base #x50
+  :method-count-assert 23
+  :size-assert         #xcc
+  :flag-assert         #x17005000cc
+  (:methods
+    (shatter () _type_ :state 20)
+    (idle () _type_ :state 21)
+    (tomb-boss-catwalk-method-22 (_type_ vector int) none 22)
+    )
+  )
+
+
+(defskelgroup skel-tomb-boss-catwalk-main tomb-boss-catwalk tomb-boss-catwalk-main-lod0-jg tomb-boss-catwalk-main-idle-ja
+              ((tomb-boss-catwalk-main-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 80)
+              )
+
+(defskelgroup skel-tomb-boss-catwalk-a tomb-boss-catwalk tomb-boss-catwalk-a-lod0-jg tomb-boss-catwalk-a-idle-ja
+              ((tomb-boss-catwalk-a-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -2 0 18)
+              :origin-joint-index 30
+              )
+
+(defskelgroup skel-tomb-boss-catwalk-b tomb-boss-catwalk tomb-boss-catwalk-b-lod0-jg tomb-boss-catwalk-b-idle-ja
+              ((tomb-boss-catwalk-b-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -2 0 14)
+              :origin-joint-index 30
+              )
+
+(defskelgroup skel-tomb-boss-catwalk-c tomb-boss-catwalk tomb-boss-catwalk-c-lod0-jg tomb-boss-catwalk-c-idle-ja
+              ((tomb-boss-catwalk-c-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -2 0 14)
+              :origin-joint-index 30
+              )
+
+(defskelgroup skel-tomb-boss-catwalk-d tomb-boss-catwalk tomb-boss-catwalk-d-lod0-jg tomb-boss-catwalk-d-idle-ja
+              ((tomb-boss-catwalk-d-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -2 0 14)
+              :origin-joint-index 30
+              )
+
+(defskelgroup skel-tomb-boss-catwalk-e tomb-boss-catwalk tomb-boss-catwalk-e-lod0-jg tomb-boss-catwalk-e-idle-ja
+              ((tomb-boss-catwalk-e-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -2 0 14)
+              :origin-joint-index 18
+              )
+
+(defskelgroup skel-tomb-boss-catwalk-f tomb-boss-catwalk tomb-boss-catwalk-f-lod0-jg tomb-boss-catwalk-f-idle-ja
+              ((tomb-boss-catwalk-f-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -2 0 14)
+              :origin-joint-index 30
+              )
+
+(defskelgroup skel-tomb-boss-catwalk-g tomb-boss-catwalk tomb-boss-catwalk-g-lod0-jg tomb-boss-catwalk-g-idle-ja
+              ((tomb-boss-catwalk-g-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -2 0 14)
+              :origin-joint-index 30
+              )
+
+(defstate shatter (tomb-boss-catwalk)
+  :virtual #t
+  :enter (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
+    (logclear! (-> self draw status) (draw-control-status no-draw-bounds))
+    (set! (-> self draw bounds w) 245760.0)
+    (let ((gp-0 (new 'stack-no-clear 'vector)))
+      (case (-> self which-look)
+        ((1)
+         (ja :group! (-> self draw art-group data 3) :num! min)
+         (set-vector! gp-0 188416.0 32768.0 -81920.0 1.0)
+         )
+        ((2)
+         (ja :group! (-> self draw art-group data 8) :num! min)
+         (set-vector! gp-0 139264.0 32768.0 -147456.0 1.0)
+         )
+        ((3)
+         (ja :group! (-> self draw art-group data 13) :num! min)
+         (set-vector! gp-0 81920.0 32768.0 -188416.0 1.0)
+         )
+        ((4)
+         (ja :group! (-> self draw art-group data 18) :num! min)
+         (set-vector! gp-0 0.0 32768.0 -200704.0 1.0)
+         )
+        ((5)
+         (ja :group! (-> self draw art-group data 23) :num! min)
+         (set-vector! gp-0 -81920.0 32768.0 -188416.0 1.0)
+         )
+        ((6)
+         (ja :group! (-> self draw art-group data 28) :num! min)
+         (set-vector! gp-0 -139264.0 32768.0 -147456.0 1.0)
+         )
+        ((7)
+         (ja :group! (-> self draw art-group data 33) :num! min)
+         (set-vector! gp-0 -188416.0 32768.0 -81920.0 1.0)
+         )
+        )
+      (vector+! gp-0 gp-0 (-> self root-override trans))
+      (let ((s5-7 (get-process *default-dead-pool* part-tracker #x4000)))
+        (when s5-7
+          (let ((t9-8 (method-of-type part-tracker activate)))
+            (t9-8
+              (the-as part-tracker s5-7)
+              *entity-pool*
+              (symbol->string (-> part-tracker symbol))
+              (the-as pointer #x70004000)
+              )
+            )
+          (let ((t9-9 run-function-in-process)
+                (a0-54 s5-7)
+                (a1-11 part-tracker-init)
+                (a2-11 (-> *part-group-id-table* 717))
+                (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-9)
+             a0-54
+             a1-11
+             a2-11
+             a3-1
+             t0-0
+             t1-0
+             t2-0
+             t3-0
+             )
+            )
+          (-> s5-7 ppointer)
+          )
+        )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    (ja :num! (seek!))
+    (if (ja-done? 0)
+        (deactivate self)
+        )
+    (none)
+    )
+  :code (the-as (function none :behavior tomb-boss-catwalk) sleep-code)
+  :post (the-as (function none :behavior tomb-boss-catwalk) ja-post)
+  )
+
+(defstate idle (tomb-boss-catwalk)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as object (case event-type
+                     (('catwalk-hit)
+                      (when (zero? (-> self which-look))
+                        (case (-> event param 0)
+                          ((1)
+                           (the-as object (setup-masks (-> self draw) 0 1))
+                           )
+                          ((2)
+                           (the-as object (setup-masks (-> self draw) 0 2))
+                           )
+                          ((3)
+                           (the-as object (setup-masks (-> self draw) 0 4))
+                           )
+                          ((4)
+                           (the-as object (setup-masks (-> self draw) 0 8))
+                           )
+                          ((5)
+                           (the-as object (setup-masks (-> self draw) 0 16))
+                           )
+                          ((6)
+                           (the-as object (setup-masks (-> self draw) 0 32))
+                           )
+                          ((7)
+                           (the-as object (setup-masks (-> self draw) 0 64))
+                           )
+                          )
+                        )
+                      )
+                     (('green-hit)
+                      (when (nonzero? (-> self which-look))
+                        (send-event (ppointer->process (-> self parent)) 'catwalk-hit (-> self which-look))
+                        (go-virtual shatter)
+                        )
+                      )
+                     )
+            )
+    )
+  :code (the-as (function none :behavior tomb-boss-catwalk) sleep-code)
+  )
+
+(defmethod tomb-boss-catwalk-method-22 tomb-boss-catwalk ((obj tomb-boss-catwalk) (arg0 vector) (arg1 int))
+  (case arg1
+    ((1)
+     (let ((s3-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+       (let ((v1-3 (new 'process 'collide-shape-prim-mesh s3-0 (the-as uint 0) (the-as uint 0))))
+         (set! (-> v1-3 prim-core collide-as) (collide-spec obstacle))
+         (set! (-> v1-3 prim-core collide-with) (collide-spec jak bot player-list))
+         (set! (-> v1-3 prim-core action) (collide-action solid))
+         (set! (-> v1-3 transform-index) 30)
+         (set-vector! (-> v1-3 local-sphere) 0.0 -12288.0 0.0 57344.0)
+         (set! (-> s3-0 total-prims) (the-as uint 1))
+         (set! (-> s3-0 root-prim) v1-3)
+         )
+       (set! (-> s3-0 nav-radius) 8192.0)
+       (let ((v1-5 (-> s3-0 root-prim)))
+         (set! (-> s3-0 backup-collide-as) (-> v1-5 prim-core collide-as))
+         (set! (-> s3-0 backup-collide-with) (-> v1-5 prim-core collide-with))
+         )
+       (set! (-> obj root-override) (the-as collide-shape-moving s3-0))
+       )
+     )
+    ((2)
+     (let ((s3-1 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+       (let ((v1-9 (new 'process 'collide-shape-prim-mesh s3-1 (the-as uint 0) (the-as uint 0))))
+         (set! (-> v1-9 prim-core collide-as) (collide-spec obstacle))
+         (set! (-> v1-9 prim-core collide-with) (collide-spec jak bot player-list))
+         (set! (-> v1-9 prim-core action) (collide-action solid))
+         (set! (-> v1-9 transform-index) 30)
+         (set-vector! (-> v1-9 local-sphere) 0.0 0.0 0.0 65536.0)
+         (set! (-> s3-1 total-prims) (the-as uint 1))
+         (set! (-> s3-1 root-prim) v1-9)
+         )
+       (set! (-> s3-1 nav-radius) 8192.0)
+       (let ((v1-11 (-> s3-1 root-prim)))
+         (set! (-> s3-1 backup-collide-as) (-> v1-11 prim-core collide-as))
+         (set! (-> s3-1 backup-collide-with) (-> v1-11 prim-core collide-with))
+         )
+       (set! (-> obj root-override) (the-as collide-shape-moving s3-1))
+       )
+     )
+    ((3)
+     (let ((s3-2 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+       (let ((v1-15 (new 'process 'collide-shape-prim-mesh s3-2 (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 player-list))
+         (set! (-> v1-15 prim-core action) (collide-action solid))
+         (set! (-> v1-15 transform-index) 30)
+         (set-vector! (-> v1-15 local-sphere) 0.0 0.0 0.0 65536.0)
+         (set! (-> s3-2 total-prims) (the-as uint 1))
+         (set! (-> s3-2 root-prim) v1-15)
+         )
+       (set! (-> s3-2 nav-radius) 8192.0)
+       (let ((v1-17 (-> s3-2 root-prim)))
+         (set! (-> s3-2 backup-collide-as) (-> v1-17 prim-core collide-as))
+         (set! (-> s3-2 backup-collide-with) (-> v1-17 prim-core collide-with))
+         )
+       (set! (-> obj root-override) (the-as collide-shape-moving s3-2))
+       )
+     )
+    ((4)
+     (let ((s3-3 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+       (let ((v1-21 (new 'process 'collide-shape-prim-mesh s3-3 (the-as uint 0) (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 player-list))
+         (set! (-> v1-21 prim-core action) (collide-action solid))
+         (set! (-> v1-21 transform-index) 30)
+         (set-vector! (-> v1-21 local-sphere) 0.0 0.0 0.0 65536.0)
+         (set! (-> s3-3 total-prims) (the-as uint 1))
+         (set! (-> s3-3 root-prim) v1-21)
+         )
+       (set! (-> s3-3 nav-radius) 8192.0)
+       (let ((v1-23 (-> s3-3 root-prim)))
+         (set! (-> s3-3 backup-collide-as) (-> v1-23 prim-core collide-as))
+         (set! (-> s3-3 backup-collide-with) (-> v1-23 prim-core collide-with))
+         )
+       (set! (-> obj root-override) (the-as collide-shape-moving s3-3))
+       )
+     )
+    ((5)
+     (let ((s3-4 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+       (let ((v1-27 (new 'process 'collide-shape-prim-mesh s3-4 (the-as uint 0) (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 player-list))
+         (set! (-> v1-27 prim-core action) (collide-action solid))
+         (set! (-> v1-27 transform-index) 18)
+         (set-vector! (-> v1-27 local-sphere) 0.0 0.0 0.0 65536.0)
+         (set! (-> s3-4 total-prims) (the-as uint 1))
+         (set! (-> s3-4 root-prim) v1-27)
+         )
+       (set! (-> s3-4 nav-radius) 8192.0)
+       (let ((v1-29 (-> s3-4 root-prim)))
+         (set! (-> s3-4 backup-collide-as) (-> v1-29 prim-core collide-as))
+         (set! (-> s3-4 backup-collide-with) (-> v1-29 prim-core collide-with))
+         )
+       (set! (-> obj root-override) (the-as collide-shape-moving s3-4))
+       )
+     )
+    ((6)
+     (let ((s3-5 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+       (let ((v1-33 (new 'process 'collide-shape-prim-mesh s3-5 (the-as uint 0) (the-as uint 0))))
+         (set! (-> v1-33 prim-core collide-as) (collide-spec obstacle))
+         (set! (-> v1-33 prim-core collide-with) (collide-spec jak bot player-list))
+         (set! (-> v1-33 prim-core action) (collide-action solid))
+         (set! (-> v1-33 transform-index) 30)
+         (set-vector! (-> v1-33 local-sphere) 0.0 0.0 0.0 65536.0)
+         (set! (-> s3-5 total-prims) (the-as uint 1))
+         (set! (-> s3-5 root-prim) v1-33)
+         )
+       (set! (-> s3-5 nav-radius) 8192.0)
+       (let ((v1-35 (-> s3-5 root-prim)))
+         (set! (-> s3-5 backup-collide-as) (-> v1-35 prim-core collide-as))
+         (set! (-> s3-5 backup-collide-with) (-> v1-35 prim-core collide-with))
+         )
+       (set! (-> obj root-override) (the-as collide-shape-moving s3-5))
+       )
+     )
+    ((7)
+     (let ((s3-6 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+       (let ((v1-39 (new 'process 'collide-shape-prim-mesh s3-6 (the-as uint 0) (the-as uint 0))))
+         (set! (-> v1-39 prim-core collide-as) (collide-spec obstacle))
+         (set! (-> v1-39 prim-core collide-with) (collide-spec jak bot player-list))
+         (set! (-> v1-39 prim-core action) (collide-action solid))
+         (set! (-> v1-39 transform-index) 30)
+         (set-vector! (-> v1-39 local-sphere) 0.0 0.0 0.0 65536.0)
+         (set! (-> s3-6 total-prims) (the-as uint 1))
+         (set! (-> s3-6 root-prim) v1-39)
+         )
+       (set! (-> s3-6 nav-radius) 8192.0)
+       (let ((v1-41 (-> s3-6 root-prim)))
+         (set! (-> s3-6 backup-collide-as) (-> v1-41 prim-core collide-as))
+         (set! (-> s3-6 backup-collide-with) (-> v1-41 prim-core collide-with))
+         )
+       (set! (-> obj root-override) (the-as collide-shape-moving s3-6))
+       )
+     )
+    (else
+      (let ((s3-7 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+        (let ((s2-0 (new 'process 'collide-shape-prim-group s3-7 (the-as uint 8) 0)))
+          (set! (-> s3-7 total-prims) (the-as uint 9))
+          (set! (-> s2-0 prim-core collide-as) (collide-spec obstacle))
+          (set! (-> s2-0 prim-core collide-with) (collide-spec jak player-list))
+          (set! (-> s2-0 prim-core action) (collide-action solid))
+          (set! (-> s2-0 transform-index) 3)
+          (set-vector! (-> s2-0 local-sphere) 0.0 0.0 0.0 327680.0)
+          (set! (-> s3-7 root-prim) s2-0)
+          )
+        (let ((v1-52 (new 'process 'collide-shape-prim-mesh s3-7 (the-as uint 7) (the-as uint 0))))
+          (set! (-> v1-52 prim-core collide-as) (collide-spec obstacle))
+          (set! (-> v1-52 prim-core collide-with) (collide-spec jak bot player-list))
+          (set! (-> v1-52 prim-core action) (collide-action solid))
+          (set! (-> v1-52 transform-index) 11)
+          (set-vector! (-> v1-52 local-sphere) 0.0 114688.0 0.0 65536.0)
+          )
+        (let ((v1-54 (new 'process 'collide-shape-prim-mesh s3-7 (the-as uint 6) (the-as uint 0))))
+          (set! (-> v1-54 prim-core collide-as) (collide-spec obstacle))
+          (set! (-> v1-54 prim-core collide-with) (collide-spec jak bot player-list))
+          (set! (-> v1-54 prim-core action) (collide-action solid))
+          (set! (-> v1-54 transform-index) 10)
+          (set-vector! (-> v1-54 local-sphere) 0.0 114688.0 0.0 65536.0)
+          )
+        (let ((v1-56 (new 'process 'collide-shape-prim-mesh s3-7 (the-as uint 5) (the-as uint 0))))
+          (set! (-> v1-56 prim-core collide-as) (collide-spec obstacle))
+          (set! (-> v1-56 prim-core collide-with) (collide-spec jak bot player-list))
+          (set! (-> v1-56 prim-core action) (collide-action solid))
+          (set! (-> v1-56 transform-index) 9)
+          (set-vector! (-> v1-56 local-sphere) 0.0 114688.0 0.0 57344.0)
+          )
+        (let ((v1-58 (new 'process 'collide-shape-prim-mesh s3-7 (the-as uint 4) (the-as uint 0))))
+          (set! (-> v1-58 prim-core collide-as) (collide-spec obstacle))
+          (set! (-> v1-58 prim-core collide-with) (collide-spec jak bot player-list))
+          (set! (-> v1-58 prim-core action) (collide-action solid))
+          (set! (-> v1-58 transform-index) 8)
+          (set-vector! (-> v1-58 local-sphere) 0.0 114688.0 0.0 61440.0)
+          )
+        (let ((v1-60 (new 'process 'collide-shape-prim-mesh s3-7 (the-as uint 3) (the-as uint 0))))
+          (set! (-> v1-60 prim-core collide-as) (collide-spec obstacle))
+          (set! (-> v1-60 prim-core collide-with) (collide-spec jak bot player-list))
+          (set! (-> v1-60 prim-core action) (collide-action solid))
+          (set! (-> v1-60 transform-index) 7)
+          (set-vector! (-> v1-60 local-sphere) 0.0 114688.0 0.0 61440.0)
+          )
+        (let ((v1-62 (new 'process 'collide-shape-prim-mesh s3-7 (the-as uint 2) (the-as uint 0))))
+          (set! (-> v1-62 prim-core collide-as) (collide-spec obstacle))
+          (set! (-> v1-62 prim-core collide-with) (collide-spec jak bot player-list))
+          (set! (-> v1-62 prim-core action) (collide-action solid))
+          (set! (-> v1-62 transform-index) 6)
+          (set-vector! (-> v1-62 local-sphere) -8192.0 114688.0 0.0 57344.0)
+          )
+        (let ((v1-64 (new 'process 'collide-shape-prim-mesh s3-7 (the-as uint 1) (the-as uint 0))))
+          (set! (-> v1-64 prim-core collide-as) (collide-spec obstacle))
+          (set! (-> v1-64 prim-core collide-with) (collide-spec jak bot player-list))
+          (set! (-> v1-64 prim-core action) (collide-action solid))
+          (set! (-> v1-64 transform-index) 5)
+          (set-vector! (-> v1-64 local-sphere) -4096.0 114688.0 0.0 57344.0)
+          )
+        (let ((v1-66 (new 'process 'collide-shape-prim-mesh s3-7 (the-as uint 0) (the-as uint 0))))
+          (set! (-> v1-66 prim-core collide-as) (collide-spec obstacle))
+          (set! (-> v1-66 prim-core collide-with) (collide-spec jak bot player-list))
+          (set! (-> v1-66 prim-core action) (collide-action solid))
+          (set! (-> v1-66 transform-index) 4)
+          (set-vector! (-> v1-66 local-sphere) 0.0 114688.0 0.0 65536.0)
+          )
+        (set! (-> s3-7 nav-radius) 8192.0)
+        (let ((v1-68 (-> s3-7 root-prim)))
+          (set! (-> s3-7 backup-collide-as) (-> v1-68 prim-core collide-as))
+          (set! (-> s3-7 backup-collide-with) (-> v1-68 prim-core collide-with))
+          )
+        (set! (-> obj root-override) (the-as collide-shape-moving s3-7))
+        )
+      )
+    )
+  (set! (-> obj root-override trans quad) (-> arg0 quad))
+  (case arg1
+    ((1)
+     (initialize-skeleton
+       obj
+       (the-as
+         skeleton-group
+         (art-group-get-by-name *level* "skel-tomb-boss-catwalk-a" (the-as (pointer uint32) #f))
+         )
+       (the-as pair 0)
+       )
+     (logior! (-> obj draw status) (draw-control-status no-draw-bounds))
+     )
+    ((2)
+     (initialize-skeleton
+       obj
+       (the-as
+         skeleton-group
+         (art-group-get-by-name *level* "skel-tomb-boss-catwalk-b" (the-as (pointer uint32) #f))
+         )
+       (the-as pair 0)
+       )
+     (logior! (-> obj draw status) (draw-control-status no-draw-bounds))
+     )
+    ((3)
+     (initialize-skeleton
+       obj
+       (the-as
+         skeleton-group
+         (art-group-get-by-name *level* "skel-tomb-boss-catwalk-c" (the-as (pointer uint32) #f))
+         )
+       (the-as pair 0)
+       )
+     (logior! (-> obj draw status) (draw-control-status no-draw-bounds))
+     )
+    ((4)
+     (initialize-skeleton
+       obj
+       (the-as
+         skeleton-group
+         (art-group-get-by-name *level* "skel-tomb-boss-catwalk-d" (the-as (pointer uint32) #f))
+         )
+       (the-as pair 0)
+       )
+     (logior! (-> obj draw status) (draw-control-status no-draw-bounds))
+     )
+    ((5)
+     (initialize-skeleton
+       obj
+       (the-as
+         skeleton-group
+         (art-group-get-by-name *level* "skel-tomb-boss-catwalk-e" (the-as (pointer uint32) #f))
+         )
+       (the-as pair 0)
+       )
+     (logior! (-> obj draw status) (draw-control-status no-draw-bounds))
+     )
+    ((6)
+     (initialize-skeleton
+       obj
+       (the-as
+         skeleton-group
+         (art-group-get-by-name *level* "skel-tomb-boss-catwalk-f" (the-as (pointer uint32) #f))
+         )
+       (the-as pair 0)
+       )
+     (logior! (-> obj draw status) (draw-control-status no-draw-bounds))
+     )
+    ((7)
+     (initialize-skeleton
+       obj
+       (the-as
+         skeleton-group
+         (art-group-get-by-name *level* "skel-tomb-boss-catwalk-g" (the-as (pointer uint32) #f))
+         )
+       (the-as pair 0)
+       )
+     (logior! (-> obj draw status) (draw-control-status no-draw-bounds))
+     )
+    (else
+      (initialize-skeleton
+        obj
+        (the-as
+          skeleton-group
+          (art-group-get-by-name *level* "skel-tomb-boss-catwalk-main" (the-as (pointer uint32) #f))
+          )
+        (the-as pair 0)
+        )
+      )
+    )
+  (set! (-> obj root-override pause-adjust-distance) 245760.0)
+  (set! (-> obj which-look) arg1)
+  (quaternion-set! (-> obj root-override quat) 0.0 1.0 0.0 0.0)
+  (transform-post)
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! tomb-boss-catwalk ((obj tomb-boss-catwalk) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (let ((a2-1 (res-lump-value arg0 'mode uint128 :time -1000000000.0)))
+    (tomb-boss-catwalk-method-22 obj (-> arg0 extra trans) (the-as int a2-1))
+    )
+  (cleanup-for-death obj)
+  (deactivate obj)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior tomb-boss-catwalk-init-by-other tomb-boss-catwalk ((arg0 vector) (arg1 int))
+  (tomb-boss-catwalk-method-22 self arg0 arg1)
+  (set! (-> self event-hook) (-> (method-of-object self idle) event))
+  (set! (-> self draw light-index) (the-as uint 2))
+  (go-virtual idle)
+  (none)
+  )
+
+(deftype tomb-boss-catwalk-main (tomb-boss-catwalk)
+  ()
+  :heap-base #x50
+  :method-count-assert 23
+  :size-assert         #xcc
+  :flag-assert         #x17005000cc
+  )
+
+
+(deftype widow-bomb (process-focusable)
+  ((traj                  trajectory               :inline :offset-assert 208)
+   (explode-part          sparticle-launch-control         :offset-assert 248)
+   (trail-part            sparticle-launch-control         :offset-assert 252)
+   (warning-glow-part     sparticle-launch-control         :offset-assert 256)
+   (warning-spark-part    sparticle-launch-control         :offset-assert 260)
+   (impact                impact-control           :inline :offset-assert 272)
+   (which-trajectory      int32                            :offset-assert 352)
+   (next-countdown-tick   time-frame                       :offset-assert 360)
+   (skid-part             sparticle-launch-control         :offset-assert 368)
+   (x-rotate              float                            :offset-assert 372)
+   (y-rotate              float                            :offset-assert 376)
+   (spin-jm               joint-mod                        :offset-assert 380)
+   (firework-sound-played symbol                           :offset-assert 384)
+   (steam-sound           uint32                           :offset-assert 388)
+   (launch                vector                   :inline :offset-assert 400)
+   (launch-pos            vector                   :inline :offset-assert 416)
+   (fizzle-timer          time-frame                       :offset-assert 432)
+   )
+  :heap-base #x140
+  :method-count-assert 35
+  :size-assert         #x1b8
+  :flag-assert         #x23014001b8
+  (:methods
+    (freefall () _type_ :state 27)
+    (back-atcha () _type_ :state 28)
+    (explode () _type_ :state 29)
+    (smoke () _type_ :state 30)
+    (idle () _type_ :state 31)
+    (widow-bomb-method-32 (_type_) none 32)
+    (widow-bomb-method-33 (_type_) none 33)
+    (widow-bomb-method-34 (_type_) none 34)
+    )
+  )
+
+
+(defskelgroup skel-widow-bomb widow-bomb widow-bomb-lod0-jg widow-bomb-idle-ja
+              ((widow-bomb-lod0-mg (meters 20)) (widow-bomb-lod1-mg (meters 40)) (widow-bomb-lod2-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+;; ERROR: Stack slot load at 48 mismatch: defined as size 4, got size 16
+;; ERROR: Stack slot load at 64 mismatch: defined as size 4, got size 16
+;; ERROR: Stack slot load at 48 mismatch: defined as size 4, got size 16
+;; ERROR: Stack slot load at 64 mismatch: defined as size 4, got size 16
+;; ERROR: Stack slot load at 48 mismatch: defined as size 4, got size 16
+;; ERROR: Stack slot load at 64 mismatch: defined as size 4, got size 16
+(defmethod widow-bomb-method-34 widow-bomb ((obj widow-bomb))
+  (local-vars (sv-48 float) (sv-64 float))
+  (let ((s5-0 (new 'stack-no-clear 'quaternion))
+        (gp-0 (new 'stack-no-clear 'quaternion))
+        )
+    (let ((s3-0 quaternion-set!)
+          (s2-0 s5-0)
+          (s1-0 (sin (* 0.5 (-> obj x-rotate))))
+          (s0-0 0.0)
+          )
+      (set! sv-48 (the-as float 0.0))
+      (let ((t0-0 (cos (* 0.5 (-> obj x-rotate)))))
+        (s3-0 s2-0 s1-0 s0-0 sv-48 t0-0)
+        )
+      )
+    (let ((s3-1 quaternion-set!)
+          (s2-1 gp-0)
+          (s1-1 0.0)
+          (s0-1 (sin (* 0.5 (-> obj y-rotate))))
+          )
+      (set! sv-64 (the-as float 0.0))
+      (let ((t0-1 (cos (* 0.5 (-> obj y-rotate)))))
+        (s3-1 s2-1 s1-1 s0-1 sv-64 t0-1)
+        )
+      )
+    (quaternion-normalize! (quaternion*! (-> obj spin-jm quat) gp-0 s5-0))
+    )
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior widow-bomb-handler widow-bomb ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (local-vars (v1-13 float))
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf1 :class vf)
+         (vf2 :class vf)
+         )
+    (init-vf0-vector)
+    (case arg2
+      (('attack)
+       (cond
+         ((= (-> arg0 type) target)
+          (let ((gp-0 (new 'stack-no-clear 'vector))
+                (f30-0 32768.0)
+                )
+            (let* ((s4-0 (ppointer->process (-> self parent)))
+                   (v1-5 (if (type? s4-0 widow)
+                             (the-as widow s4-0)
+                             )
+                         )
+                   )
+              (vector-! gp-0 (-> self root-override trans) (-> (the-as widow arg0) root trans))
+              (set! (-> gp-0 y) 0.0)
+              (cond
+                (v1-5
+                  (if (-> v1-5 flying)
+                      (set! f30-0 16384.0)
+                      )
+                  (let ((s4-1 (vector<-cspace! (new 'stack-no-clear 'vector) (-> v1-5 node-list data 3)))
+                        (s5-1 (new 'stack-no-clear 'vector))
+                        )
+                    (let ((f28-0 20480.0))
+                      (vector-! s4-1 s4-1 (-> self root-override trans))
+                      (let ((t9-2 vector-normalize!)
+                            (a0-14 gp-0)
+                            (v1-9 s4-1)
+                            )
+                        (t9-2 a0-14 (sqrtf (+ (* (-> v1-9 x) (-> v1-9 x)) (* (-> v1-9 z) (-> v1-9 z)))))
+                        )
+                      (set! (-> gp-0 y) (-> s4-1 y))
+                      (vector-! s5-1 s4-1 gp-0)
+                      (let* ((f0-6 f28-0)
+                             (f0-8 (* f0-6 f0-6))
+                             )
+                        (.lvf vf1 (&-> s5-1 quad))
+                        (.add.w.vf vf2 vf0 vf0 :mask #b1)
+                        (.mul.vf vf1 vf1 vf1)
+                        (.mul.x.vf acc vf2 vf1 :mask #b1)
+                        (.add.mul.y.vf acc vf2 vf1 acc :mask #b1)
+                        (.add.mul.z.vf vf1 vf2 vf1 acc :mask #b1)
+                        (.mov v1-13 vf1)
+                        (if (< f0-8 v1-13)
+                            (vector-normalize! s5-1 f28-0)
+                            )
+                        )
+                      )
+                    (vector+! gp-0 gp-0 s5-1)
+                    )
+                  )
+                (else
+                  (vector-normalize! gp-0 200704.0)
+                  )
+                )
+              )
+            (vector+! gp-0 gp-0 (-> self root-override trans))
+            (setup-from-to-duration-and-height! (-> self traj) (-> self root-override trans) gp-0 225.0 f30-0)
+            )
+          (send-event (ppointer->process (-> self parent)) 'bomb-kicked)
+          (go-virtual back-atcha)
+          )
+         (else
+           (go-virtual explode)
+           )
+         )
+       )
+      (('fizzle)
+       (let* ((gp-1 (-> self clock frame-counter))
+              (f30-1 600.0)
+              (v1-34 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+              (v1-35 (the-as number (logior #x3f800000 v1-34)))
+              )
+         (set! (-> self fizzle-timer) (- gp-1 (the-as time-frame (the int (* f30-1 (+ -1.0 (the-as float v1-35)))))))
+         )
+       )
+      )
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior widow-bomb-back-handler widow-bomb ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (case arg2
+    (('impact-control)
+     (let* ((s4-0 (ppointer->process (-> self parent)))
+            (s5-0 (if (type? s4-0 widow)
+                      (the-as widow s4-0)
+                      )
+                  )
+            )
+       (when s5-0
+         (let ((a1-3 (vector<-cspace! (new 'stack-no-clear 'vector) (-> s5-0 node-list data 3))))
+           (when (and (< (vector-vector-distance (-> self root-override trans) a1-3) 49152.0) (not (-> s5-0 flying)))
+             (send-event s5-0 'bomb-hit (-> self root-override trans) 1)
+             (go-virtual explode)
+             )
+           )
+         )
+       )
+     (let ((s5-1 arg0))
+       (when (if (type? s5-1 widow)
+                 s5-1
+                 )
+         (send-event arg0 'bomb-hit (-> self root-override trans) 1)
+         (go-virtual explode)
+         )
+       )
+     )
+    (('fizzle)
+     (let* ((gp-1 (-> self clock frame-counter))
+            (f30-0 600.0)
+            (v1-34 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+            (v1-35 (the-as number (logior #x3f800000 v1-34)))
+            )
+       (set! (-> self fizzle-timer) (- gp-1 (the-as time-frame (the int (* f30-0 (+ -1.0 (the-as float v1-35)))))))
+       )
+     )
+    )
+  (none)
+  )
+
+(defstate freefall (widow-bomb)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow-bomb) widow-bomb-back-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :trans (behavior ()
+    (if (and (nonzero? (-> self fizzle-timer))
+             (>= (- (-> self clock frame-counter) (-> self fizzle-timer)) (seconds 3))
+             )
+        (go-virtual explode)
+        )
+    (set! (-> self x-rotate) (+ 1092.2667 (-> self x-rotate)))
+    (set! (-> self y-rotate) (+ 728.1778 (-> self y-rotate)))
+    (widow-bomb-method-34 self)
+    (spawn-with-cspace (-> self part) (-> self node-list data 3))
+    (cond
+      ((>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 4))
+       (go-virtual explode)
+       )
+      (else
+        (vector-v++!
+          (-> self root-override transv)
+          (compute-acc-due-to-gravity (the-as collide-shape-moving (-> self root-override)) (new-stack-vector0) 1.0)
+          )
+        (let ((a2-1 (new 'stack-no-clear 'collide-query)))
+          (set! (-> a2-1 collide-with) (collide-spec backgnd enemy obstacle hit-by-others-list pusher))
+          (set! (-> a2-1 ignore-process0) self)
+          (set! (-> a2-1 ignore-process1) #f)
+          (set! (-> a2-1 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+          (set! (-> a2-1 action-mask) (collide-action solid))
+          (fill-cache-integrate-and-collide (-> self root-override) (-> self root-override transv) a2-1 (meters 0))
+          )
+        )
+      )
+    (ja :num! (loop!))
+    (none)
+    )
+  :code (the-as (function none :behavior widow-bomb) sleep-code)
+  :post (the-as (function none :behavior widow-bomb) transform-post)
+  )
+
+(defstate back-atcha (widow-bomb)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow-bomb) widow-bomb-back-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (initialize
+      (-> self impact)
+      self
+      3
+      4096.0
+      (collide-spec backgnd enemy obstacle hit-by-others-list player-list)
+      )
+    (let ((v1-5 (-> self root-override root-prim)))
+      (logior! (-> v1-5 prim-core collide-with) (collide-spec enemy))
+      (logclear! (-> v1-5 prim-core collide-with) (collide-spec jak))
+      )
+    (none)
+    )
+  :trans (behavior ()
+    (if (and (nonzero? (-> self fizzle-timer))
+             (>= (- (-> self clock frame-counter) (-> self fizzle-timer)) (seconds 3))
+             )
+        (go-virtual explode)
+        )
+    (set! (-> self x-rotate) (+ 4369.067 (-> self x-rotate)))
+    (set! (-> self y-rotate) (+ 3458.8445 (-> self y-rotate)))
+    (widow-bomb-method-34 self)
+    (cond
+      ((>= (- (-> self clock frame-counter) (-> self state-time)) (the int (-> self traj time)))
+       (compute-transv-at-time (-> self traj) (-> self traj time) (-> self root-override transv))
+       (vector-float*! (-> self root-override transv) (-> self root-override transv) 300.0)
+       (go-virtual freefall)
+       )
+      (else
+        (compute-trans-at-time
+          (-> self traj)
+          (the float (- (-> self clock frame-counter) (-> self state-time)))
+          (-> self root-override trans)
+          )
+        (update-from-cspace (-> self impact))
+        (when (>= (- (-> self clock frame-counter) (-> self state-time)) 1)
+          (let* ((a1-4 (new 'stack-no-clear 'collide-query))
+                 (f0-10 (impact-control-method-11
+                          (-> self impact)
+                          a1-4
+                          self
+                          (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noproj #x1 :noendlessfall #x1)
+                          )
+                        )
+                 )
+            (when (< 0.0 f0-10)
+              (set! (-> self root-override trans quad) (-> self impact trans 1 quad))
+              (compute-transv-at-time
+                (-> self traj)
+                (the float (- (-> self clock frame-counter) (-> self state-time)))
+                (-> self root-override transv)
+                )
+              (vector-float*! (-> self root-override transv) (-> self root-override transv) 300.0)
+              (go-virtual freefall)
+              )
+            )
+          )
+        (spawn-with-cspace (-> self part) (-> self node-list data 3))
+        )
+      )
+    (ja :num! (loop!))
+    (none)
+    )
+  :code (the-as (function none :behavior widow-bomb) sleep-code)
+  :post (the-as (function none :behavior widow-bomb) transform-post)
+  )
+
+(defstate explode (widow-bomb)
+  :virtual #t
+  :enter (behavior ()
+    (let* ((a0-1 (target-pos 0))
+           (f0-0 (vector-vector-distance-squared a0-1 (-> self root-override trans)))
+           (f1-0 16384.0)
+           )
+      (when (< f0-0 (* f1-0 f1-0))
+        (let ((a1-1 (new 'stack-no-clear 'event-message-block)))
+          (set! (-> a1-1 from) (process->ppointer self))
+          (set! (-> a1-1 num-params) 2)
+          (set! (-> a1-1 message) 'attack)
+          (set! (-> a1-1 param 0) (the-as uint #f))
+          (let ((v1-7 (new 'static 'attack-info :mask (attack-info-mask mode shove-back shove-up id))))
+            (let* ((a0-3 *game-info*)
+                   (a2-1 (+ (-> a0-3 attack-id) 1))
+                   )
+              (set! (-> a0-3 attack-id) a2-1)
+              (set! (-> v1-7 id) a2-1)
+              )
+            (set! (-> v1-7 mode) 'explode)
+            (set! (-> v1-7 shove-up) 16384.0)
+            (set! (-> v1-7 shove-back) 8192.0)
+            (set! (-> a1-1 param 1) (the-as uint v1-7))
+            )
+          (send-event-function *target* a1-1)
+          )
+        )
+      )
+    (activate! *camera-smush-control* 819.2 37 210 1.0 0.995 (-> self clock))
+    (ja-channel-set! 0)
+    (let ((v1-12 (-> self root-override root-prim)))
+      (set! (-> v1-12 prim-core collide-as) (collide-spec))
+      (set! (-> v1-12 prim-core collide-with) (collide-spec))
+      )
+    0
+    (sound-play "w-bomb-explode")
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :trans (behavior ()
+    (cond
+      ((< (- (-> self clock frame-counter) (-> self state-time)) (seconds 2))
+       (let ((a1-0 (new 'stack-no-clear 'vector)))
+         (set! (-> a1-0 quad) (-> self root-override trans quad))
+         (set! (-> a1-0 y) (+ 2048.0 (-> a1-0 y)))
+         (spawn (-> self explode-part) a1-0)
+         )
+       )
+      ((not (-> self child))
+       (deactivate self)
+       )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior widow-bomb) sleep-code)
+  :post (the-as (function none :behavior widow-bomb) ja-post)
+  )
+
+(defmethod widow-bomb-method-32 widow-bomb ((obj widow-bomb))
+  (with-pp
+    (spawn-with-cspace (-> obj part) (-> obj node-list data 3))
+    (sound-play "w-bomb-steam" :id (the-as sound-id (-> obj steam-sound)) :position (-> obj root-override trans))
+    (let ((s5-0 (the-as int (- (-> pp clock frame-counter) (-> obj state-time)))))
+      (if (nonzero? (-> obj fizzle-timer))
+          (set! s5-0 (max
+                       (the-as time-frame s5-0)
+                       (- (seconds 12) (- (seconds 3) (- (-> pp clock frame-counter) (-> obj fizzle-timer))))
+                       )
+                )
+          )
+      (if (< 3600 s5-0)
+          (go (method-of-object obj explode))
+          )
+      (when (< 3000 s5-0)
+        (spawn-with-cspace (-> obj warning-spark-part) (-> obj node-list data 3))
+        (when (not (-> obj firework-sound-played))
+          (set! (-> obj firework-sound-played) #t)
+          (sound-play "w-bomb-firewrks")
+          )
+        )
+      (let* ((v1-27 (* s5-0 s5-0))
+             (a0-10 3600)
+             (v1-28 (- (* a0-10 a0-10) v1-27))
+             )
+        (when (< v1-28 (-> obj next-countdown-tick))
+          (let ((a0-14 540))
+            (set! (-> obj next-countdown-tick) (the-as time-frame (- v1-28 (mod v1-28 (* a0-14 a0-14)))))
+            )
+          (let ((s5-2 (new 'stack-no-clear 'vector)))
+            (vector<-cspace! s5-2 (-> obj node-list data 7))
+            (spawn (-> obj warning-glow-part) s5-2)
+            (vector<-cspace! s5-2 (-> obj node-list data 6))
+            (spawn (-> obj warning-glow-part) s5-2)
+            (vector<-cspace! s5-2 (-> obj node-list data 5))
+            (spawn (-> obj warning-glow-part) s5-2)
+            (vector<-cspace! s5-2 (-> obj node-list data 4))
+            (spawn (-> obj warning-glow-part) s5-2)
+            )
+          (sound-play "w-bomb-timer")
+          )
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+(defstate smoke (widow-bomb)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow-bomb) widow-bomb-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (let* ((v1-2 3600)
+           (v1-3 (* v1-2 v1-2))
+           (a0-0 540)
+           )
+      (set! (-> self next-countdown-tick) (the-as time-frame (- v1-3 (mod v1-3 (* a0-0 a0-0)))))
+      )
+    (set! (-> self steam-sound) (the-as uint (new-sound-id)))
+    (none)
+    )
+  :exit (behavior ()
+    (sound-stop (the-as sound-id (-> self steam-sound)))
+    (none)
+    )
+  :trans (behavior ()
+    (widow-bomb-method-32 self)
+    (ja :num! (loop!))
+    (none)
+    )
+  :code (the-as (function none :behavior widow-bomb) sleep-code)
+  :post (the-as (function none :behavior widow-bomb) ja-post)
+  )
+
+(defmethod widow-bomb-method-33 widow-bomb ((obj widow-bomb))
+  (let ((gp-0 (new 'stack-no-clear 'matrix)))
+    (set-vector! (-> gp-0 vector 1) 0.0 1.0 0.0 1.0)
+    (vector-! (-> gp-0 vector 2) (the-as vector (-> obj impact trans)) (-> obj impact trans 1))
+    (vector-cross! (the-as vector (-> gp-0 vector)) (-> gp-0 vector 1) (-> gp-0 vector 2))
+    (vector-normalize! (the-as vector (-> gp-0 vector)) 1.0)
+    (vector-cross! (-> gp-0 vector 2) (the-as vector (-> gp-0 vector)) (-> gp-0 vector 1))
+    (vector<-cspace! (-> gp-0 trans) (-> obj node-list data 3))
+    (set! (-> gp-0 vector 0 w) 0.0)
+    (set! (-> gp-0 vector 1 w) 0.0)
+    (set! (-> gp-0 vector 2 w) 0.0)
+    (set! (-> gp-0 trans w) 1.0)
+    (spawn-with-matrix (-> obj skid-part) gp-0)
+    )
+  (none)
+  )
+
+(defstate idle (widow-bomb)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (let ((v1-0 event-type))
+      (the-as
+        object
+        (cond
+          ((or (= v1-0 'touch) (= v1-0 'bonk))
+           (when (< (-> self which-trajectory) 2)
+             (let ((a1-1 (new 'stack-no-clear 'event-message-block)))
+               (set! (-> a1-1 from) (process->ppointer self))
+               (set! (-> a1-1 num-params) 2)
+               (set! (-> a1-1 message) 'attack)
+               (set! (-> a1-1 param 0) (the-as uint #f))
+               (let ((v1-5 (new 'static 'attack-info :mask (attack-info-mask shove-back shove-up id))))
+                 (let* ((a0-2 *game-info*)
+                        (a2-2 (+ (-> a0-2 attack-id) 1))
+                        )
+                   (set! (-> a0-2 attack-id) a2-2)
+                   (set! (-> v1-5 id) a2-2)
+                   )
+                 (set! (-> v1-5 shove-up) 4096.0)
+                 (set! (-> v1-5 shove-back) 12288.0)
+                 (set! (-> a1-1 param 1) (the-as uint v1-5))
+                 )
+               (send-event-function *target* a1-1)
+               )
+             )
+           )
+          ((= v1-0 'impact-control)
+           (if (and (!= proc self) (!= proc (-> self parent)))
+               (send-event proc 'bomb-hit (-> self root-override trans) 1)
+               )
+           )
+          ((= v1-0 'fizzle)
+           (let* ((gp-0 (-> self clock frame-counter))
+                  (f30-0 600.0)
+                  (v1-17 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                  (v1-18 (the-as number (logior #x3f800000 v1-17)))
+                  (v0-0 (the-as object (- gp-0 (the-as time-frame (the int (* f30-0 (+ -1.0 (the-as float v1-18))))))))
+                  )
+             (set! (-> self fizzle-timer) (the-as time-frame v0-0))
+             v0-0
+             )
+           )
+          (else
+            (the-as object (widow-bomb-handler proc arg1 event-type event))
+            )
+          )
+        )
+      )
+    )
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (initialize (-> self impact) self 3 4096.0 (collide-spec backgnd obstacle hit-by-others-list player-list))
+    (none)
+    )
+  :exit (behavior ()
+    (when (nonzero? (-> self fizzle-timer))
+      (let* ((gp-0 (-> self clock frame-counter))
+             (f30-0 600.0)
+             (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+             (v1-5 (the-as number (logior #x3f800000 v1-4)))
+             )
+        (set! (-> self fizzle-timer) (- gp-0 (the-as time-frame (the int (* f30-0 (+ -1.0 (the-as float v1-5)))))))
+        )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    (let ((v1-0 (-> self which-trajectory)))
+      (cond
+        ((zero? v1-0)
+         (set! (-> self x-rotate) (+ 4369.067 (-> self x-rotate)))
+         (set! (-> self y-rotate) (+ 3458.8445 (-> self y-rotate)))
+         )
+        ((= v1-0 1)
+         (set! (-> self x-rotate) (+ 7281.778 (-> self x-rotate)))
+         (set! (-> self y-rotate) 0.0)
+         )
+        (else
+          (seek! (-> self x-rotate) 65353.957 7281.778)
+          )
+        )
+      )
+    (if (< 65536.0 (-> self x-rotate))
+        (set! (-> self x-rotate) (+ -65536.0 (-> self x-rotate)))
+        )
+    (if (< 65536.0 (-> self y-rotate))
+        (set! (-> self y-rotate) (+ -65536.0 (-> self y-rotate)))
+        )
+    (widow-bomb-method-34 self)
+    (when (< (-> self root-override scale x) 1.0)
+      (let ((f0-17 (fmin 1.0 (+ 0.025 (-> self root-override scale x)))))
+        (set-vector! (-> self root-override scale) f0-17 f0-17 f0-17 1.0)
+        )
+      )
+    (cond
+      ((>= (- (-> self clock frame-counter) (-> self state-time)) (the int (-> self traj time)))
+       (let ((v1-29 (-> self which-trajectory)))
+         (cond
+           ((zero? v1-29)
+            (set! (-> self which-trajectory) 1)
+            (compute-trans-at-time
+              (-> self traj)
+              (fmin (-> self traj time) (the float (- (-> self clock frame-counter) (-> self state-time))))
+              (-> self root-override trans)
+              )
+            (set! (-> self state-time) (-> self clock frame-counter))
+            (let ((gp-1 (vector-! (new 'stack-no-clear 'vector) (-> self root-override trans) (the-as vector (-> self traj)))))
+              (set! (-> gp-1 y) 0.0)
+              (vector-normalize! gp-1 12288.0)
+              (vector+! gp-1 gp-1 (-> self root-override trans))
+              (setup-from-to-duration-and-height! (-> self traj) (-> self root-override trans) gp-1 75.0 4096.0)
+              )
+            (widow-bomb-method-33 self)
+            (sound-play "w-bomb-part1")
+            )
+           ((= v1-29 1)
+            (set! (-> self which-trajectory) 2)
+            (compute-trans-at-time
+              (-> self traj)
+              (fmin (-> self traj time) (the float (- (-> self clock frame-counter) (-> self state-time))))
+              (-> self root-override trans)
+              )
+            (set! (-> self state-time) (-> self clock frame-counter))
+            (let ((gp-4 (vector-! (new 'stack-no-clear 'vector) (-> self root-override trans) (the-as vector (-> self traj)))))
+              (set! (-> gp-4 y) 0.0)
+              (vector-normalize! gp-4 4096.0)
+              (vector+! gp-4 gp-4 (-> self root-override trans))
+              (setup-from-to-duration-and-height! (-> self traj) (-> self root-override trans) gp-4 37.5 1024.0)
+              )
+            (widow-bomb-method-33 self)
+            (sound-play "w-bomb-part2")
+            )
+           ((= v1-29 2)
+            (compute-trans-at-time
+              (-> self traj)
+              (fmin (-> self traj time) (the float (- (-> self clock frame-counter) (-> self state-time))))
+              (-> self root-override trans)
+              )
+            (set! (-> self which-trajectory) 3)
+            (let* ((gp-6 (-> self state-time))
+                   (f30-0 300.0)
+                   (v1-77 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                   (v1-78 (the-as number (logior #x3f800000 v1-77)))
+                   )
+              (set! (-> self state-time) (+ gp-6 (the int (* f30-0 (+ -1.0 (the-as float v1-78))))))
+              )
+            (widow-bomb-method-33 self)
+            )
+           (else
+             (go-virtual smoke)
+             )
+           )
+         )
+       )
+      ((< (-> self which-trajectory) 3)
+       (compute-trans-at-time
+         (-> self traj)
+         (fmin (-> self traj time) (the float (- (-> self clock frame-counter) (-> self state-time))))
+         (-> self root-override trans)
+         )
+       (when (and (zero? (-> self which-trajectory))
+                  (< (- (-> self clock frame-counter) (-> self state-time)) (the int (* 0.75 (-> self traj time))))
+                  )
+         (vector+float*! (-> self launch-pos) (-> self launch-pos) (-> self launch) (-> self clock time-adjust-ratio))
+         (vector-lerp!
+           (-> self root-override trans)
+           (-> self launch-pos)
+           (-> self root-override trans)
+           (parameter-ease-sin-clamp
+             (* 1.3333334 (/ (the float (- (-> self clock frame-counter) (-> self state-time))) (-> self traj time)))
+             )
+           )
+         )
+       (spawn-with-cspace (-> self trail-part) (-> self node-list data 3))
+       (when (zero? (-> self which-trajectory))
+         (update-from-cspace (-> self impact))
+         (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.05))
+           (let ((f0-42 (impact-control-method-11
+                          (-> self impact)
+                          (new 'stack-no-clear 'collide-query)
+                          self
+                          (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)
+                          )
+                        )
+                 )
+             (if (< 0.0 f0-42)
+                 (go-virtual explode)
+                 )
+             )
+           )
+         )
+       )
+      )
+    (ja :num! (loop!))
+    (none)
+    )
+  :code (the-as (function none :behavior widow-bomb) sleep-code)
+  :post (behavior ()
+    (transform-post)
+    (do-push-aways (-> self root-override))
+    (none)
+    )
+  )
+
+(defmethod deactivate widow-bomb ((obj widow-bomb))
+  (if (nonzero? (-> obj explode-part))
+      (kill-and-free-particles (-> obj explode-part))
+      )
+  (if (nonzero? (-> obj trail-part))
+      (kill-and-free-particles (-> obj trail-part))
+      )
+  (if (nonzero? (-> obj warning-glow-part))
+      (kill-and-free-particles (-> obj warning-glow-part))
+      )
+  (if (nonzero? (-> obj warning-spark-part))
+      (kill-and-free-particles (-> obj warning-spark-part))
+      )
+  (if (nonzero? (-> obj skid-part))
+      (kill-and-free-particles (-> obj warning-spark-part))
+      )
+  ((the-as (function process-drawable none) (find-parent-method widow-bomb 10)) obj)
+  (none)
+  )
+
+;; WARN: Return type mismatch process-drawable vs widow-bomb.
+(defmethod relocate widow-bomb ((obj widow-bomb) (arg0 int))
+  (if (nonzero? (-> obj explode-part))
+      (&+! (-> obj explode-part) arg0)
+      )
+  (if (nonzero? (-> obj trail-part))
+      (&+! (-> obj trail-part) arg0)
+      )
+  (if (nonzero? (-> obj warning-glow-part))
+      (&+! (-> obj warning-glow-part) arg0)
+      )
+  (if (nonzero? (-> obj warning-spark-part))
+      (&+! (-> obj warning-spark-part) arg0)
+      )
+  (if (nonzero? (-> obj skid-part))
+      (&+! (-> obj skid-part) arg0)
+      )
+  (if (nonzero? (-> obj spin-jm))
+      (&+! (-> obj spin-jm) arg0)
+      )
+  (the-as
+    widow-bomb
+    ((the-as (function process-drawable int process-drawable) (find-parent-method widow-bomb 7)) obj arg0)
+    )
+  )
+
+(defbehavior widow-bomb-reaction widow ((arg0 control-info) (arg1 collide-query) (arg2 vector) (arg3 vector))
+  (cshape-reaction-update-state arg0 arg1 arg3)
+  (vector--float*!
+    arg2
+    arg3
+    (-> arg0 surface-normal)
+    (* (vector-dot arg3 (-> arg0 surface-normal)) (rand-vu-float-range 1.2 1.4))
+    )
+  (send-event (-> arg0 process) 'impact-control)
+  (-> arg0 status)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior widow-bomb-init-by-other widow-bomb ((arg0 vector) (arg1 vector) (arg2 float) (arg3 float) (arg4 vector))
+  (let ((s1-0 (new 'process 'collide-shape-moving self (collide-list-enum usually-hit-by-player))))
+    (set! (-> s1-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s1-0 reaction) widow-bomb-reaction)
+    (set! (-> s1-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((v1-6 (new 'process 'collide-shape-prim-sphere s1-0 (the-as uint 0))))
+      (set! (-> v1-6 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-6 prim-core collide-with) (collide-spec backgnd jak bot hit-by-others-list player-list))
+      (set! (-> v1-6 prim-core action) (collide-action solid))
+      (set! (-> v1-6 transform-index) 3)
+      (set-vector! (-> v1-6 local-sphere) 0.0 0.0 0.0 4096.0)
+      (set! (-> s1-0 total-prims) (the-as uint 1))
+      (set! (-> s1-0 root-prim) v1-6)
+      )
+    (set! (-> s1-0 nav-radius) (* 0.75 (-> s1-0 root-prim local-sphere w)))
+    (let ((v1-9 (-> s1-0 root-prim)))
+      (set! (-> s1-0 backup-collide-as) (-> v1-9 prim-core collide-as))
+      (set! (-> s1-0 backup-collide-with) (-> v1-9 prim-core collide-with))
+      )
+    (set! (-> s1-0 event-self) 'impact-control)
+    (set! (-> self root-override) s1-0)
+    )
+  (set! (-> self root-override trans quad) (-> arg0 quad))
+  (initialize-skeleton
+    self
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-widow-bomb" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> self part) (create-launch-control (-> *part-group-id-table* 712) self))
+  (set! (-> self explode-part) (create-launch-control (-> *part-group-id-table* 711) self))
+  (set! (-> self trail-part) (create-launch-control (-> *part-group-id-table* 722) self))
+  (set! (-> self warning-glow-part) (create-launch-control (-> *part-group-id-table* 724) self))
+  (set! (-> self warning-spark-part) (create-launch-control (-> *part-group-id-table* 723) self))
+  (set! (-> self skid-part) (create-launch-control (-> *part-group-id-table* 725) self))
+  (set-vector! (-> self root-override scale) 0.5 0.5 0.5 1.0)
+  (if (< (-> arg0 y) (-> arg1 y))
+      (set! arg3 (+ arg3 (- (-> arg1 y) (-> arg0 y))))
+      )
+  (let ((a3-3 (* 0.0000061035157 (vector-vector-xz-distance arg0 arg1) arg2)))
+    (setup-from-to-duration-and-height! (-> self traj) arg0 arg1 a3-3 arg3)
+    )
+  (let ((v1-42 (new 'stack-no-clear 'vector)))
+    (vector-! v1-42 arg1 arg0)
+    (set! (-> v1-42 y) 0.0)
+    (let ((f30-1 (atan (-> v1-42 x) (-> v1-42 z))))
+      (quaternion-set! (-> self root-override quat) 0.0 (sin (* 0.5 f30-1)) 0.0 (cos (* 0.5 f30-1)))
+      )
+    )
+  (set! (-> self which-trajectory) 0)
+  (set! (-> self x-rotate) 0.0)
+  (set! (-> self y-rotate) 0.0)
+  (logclear! (-> self mask) (process-mask actor-pause))
+  (set! (-> self spin-jm) (new 'process 'joint-mod (joint-mod-mode joint-set*) self 3))
+  (set! (-> self firework-sound-played) #f)
+  (set! (-> self steam-sound) (the-as uint 0))
+  (set! (-> self launch-pos quad) (-> self root-override trans quad))
+  (set! (-> self launch quad) (-> arg4 quad))
+  (set! (-> self fizzle-timer) 0)
+  (go-virtual idle)
+  (none)
+  )
+
+(deftype heart-mar (process-drawable)
+  ((root-override collide-shape-moving  :offset 128)
+   )
+  :heap-base #x50
+  :method-count-assert 21
+  :size-assert         #xc8
+  :flag-assert         #x15005000c8
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+
+(defskelgroup skel-heart-mar heart-mar heart-mar-lod0-jg heart-mar-idle-ja
+              ((heart-mar-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              :origin-joint-index 3
+              )
+
+(defstate idle (heart-mar)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as object (case event-type
+                     (('frame)
+                      (let ((v1-3 (ja-group)))
+                        (when (not (and v1-3 (= v1-3 (-> self draw art-group data 3))))
+                          (ja :group! (-> self draw art-group data 3) :num! min)
+                          (set! (-> self draw bounds w) 81920.0)
+                          (setup-masks (-> self draw) 2 0)
+                          )
+                        )
+                      (if (and (< (ja-aframe-num 0) 775.0) (>= (the-as float (-> event param 0)) 775.0))
+                          (setup-masks (-> self draw) 0 4)
+                          )
+                      (if (>= (the-as float (-> event param 0)) 834.0)
+                          (deactivate self)
+                          )
+                      (set-tombboss-gem-light! (lerp-scale 1.0 0.0 (ja-aframe-num 0) 760.0 800.0))
+                      (ja :num-func num-func-identity :frame-num (ja-aframe (the-as float (-> event param 0)) 0))
+                      (let ((v0-9 (logclear (-> self mask) (process-mask sleep-code))))
+                        (set! (-> self mask) v0-9)
+                        v0-9
+                        )
+                      )
+                     (('grab-done)
+                      (the-as process-mask (deactivate self))
+                      )
+                     )
+            )
+    )
+  :code (behavior ()
+    (until #f
+      (logior! (-> self mask) (process-mask sleep-code))
+      (suspend)
+      (ja-post)
+      )
+    #f
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior heart-mar-init-by-other heart-mar ((arg0 vector))
+  (set! (-> self root-override) (the-as collide-shape-moving (new 'process 'trsqv)))
+  (set! (-> self root-override trans quad) (-> arg0 quad))
+  (initialize-skeleton
+    self
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-heart-mar" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (setup-masks (-> self draw) 0 2)
+  (quaternion-set! (-> self root-override quat) 0.0 1.0 0.0 0.0)
+  (set! (-> self root-override pause-adjust-distance) 245760.0)
+  (ja-post)
+  (add-connection *part-engine* self 3 self 3253 (new 'static 'vector :w 819200.0))
+  (set! (-> self draw light-index) (the-as uint 17))
+  (set-tombboss-gem-light! 1.0)
+  (go-virtual idle)
+  (none)
+  )
+
+(deftype tomb-boss-pillar (process-drawable)
+  ((root-override   collide-shape-moving      :offset        128)
+   (explode-part    sparticle-launch-control  :offset-assert 200)
+   (segs-shot       int32                     :offset-assert 204)
+   (last-pillar-hit time-frame                :offset-assert 208)
+   )
+  :heap-base #x60
+  :method-count-assert 23
+  :size-assert         #xd8
+  :flag-assert         #x17006000d8
+  (:methods
+    (idle () _type_ :state 20)
+    (break-it () _type_ :state 21)
+    (broken () _type_ :state 22)
+    )
+  )
+
+
+(defskelgroup skel-tomb-boss-pillar tomb-boss-pillar tomb-boss-pillar-lod0-jg tomb-boss-pillar-idle-ja
+              ((tomb-boss-pillar-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 4 0 9)
+              )
+
+(defbehavior damage-pillar tomb-boss-pillar ()
+  (case (-> self segs-shot)
+    ((1)
+     (setup-masks (-> self draw) 0 2)
+     )
+    ((2)
+     (setup-masks (-> self draw) 0 6)
+     )
+    ((3)
+     (setup-masks (-> self draw) 0 14)
+     )
+    ((4)
+     (setup-masks (-> self draw) 0 30)
+     )
+    ((5)
+     (setup-masks (-> self draw) 0 62)
+     )
+    ((6)
+     (setup-masks (-> self draw) 0 126)
+     )
+    ((7)
+     (setup-masks (-> self draw) 0 254)
+     )
+    ((8)
+     (setup-masks (-> self draw) 0 510)
+     )
+    ((9)
+     (setup-masks (-> self draw) 0 1022)
+     )
+    ((10)
+     (setup-masks (-> self draw) 0 2046)
+     )
+    ((11)
+     (setup-masks (-> self draw) 0 4094)
+     )
+    ((12)
+     (setup-masks (-> self draw) 0 8190)
+     )
+    ((13)
+     (setup-masks (-> self draw) 0 #x3ffe)
+     )
+    ((14)
+     (setup-masks (-> self draw) 0 #x7ffe)
+     )
+    ((15)
+     (setup-masks (-> self draw) 0 #xfffe)
+     )
+    ((16)
+     (setup-masks (-> self draw) 0 #x1fffe)
+     )
+    )
+  (none)
+  )
+
+(defbehavior tomb-boss-pillar-shrink-collision tomb-boss-pillar ()
+  (let ((v1-1 (the-as collide-shape-prim-group (-> self root-override root-prim))))
+    (let ((a0-1 (-> v1-1 child 0)))
+      (set! (-> a0-1 prim-core collide-as) (collide-spec))
+      (set! (-> a0-1 prim-core collide-with) (collide-spec))
+      )
+    0
+    (let ((v1-3 (-> v1-1 child 1)))
+      (set! (-> v1-3 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-3 prim-core collide-with) (collide-spec jak bot player-list))
+      )
+    )
+  (none)
+  )
+
+(defstate broken (tomb-boss-pillar)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self draw bounds w) 36864.0)
+    (ja :group! (-> self draw art-group data 4)
+        :num! (identity (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 4)) frames num-frames) -1)))
+        )
+    (tomb-boss-pillar-shrink-collision)
+    (ja-post)
+    (none)
+    )
+  :code (the-as (function none :behavior tomb-boss-pillar) sleep-code)
+  )
+
+(defstate break-it (tomb-boss-pillar)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self draw bounds w) 245760.0)
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :trans (behavior ()
+    (if (< (- (-> self clock frame-counter) (-> self state-time)) (seconds 1))
+        (spawn-with-cspace (-> self explode-part) (-> self node-list data 6))
+        )
+    (let ((v1-9 (ja-group)))
+      (cond
+        ((and v1-9 (= v1-9 (-> self draw art-group data 4)))
+         (ja :num! (seek!))
+         (if (ja-done? 0)
+             (go-virtual broken)
+             )
+         )
+        (else
+          (ja :group! (-> self draw art-group data 4) :num! min)
+          (activate! *camera-smush-control* 819.2 37 210 1.0 0.995 (-> self clock))
+          )
+        )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior tomb-boss-pillar) sleep-code)
+  :post (the-as (function none :behavior tomb-boss-pillar) ja-post)
+  )
+
+(defstate idle (tomb-boss-pillar)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('attack)
+       (let ((gp-0 proc))
+         (when (if (type? gp-0 widow-shot)
+                   gp-0
+                   )
+           (+! (-> self segs-shot) 1)
+           (damage-pillar)
+           (cond
+             ((>= (-> self segs-shot) 16)
+              (go-virtual break-it)
+              )
+             ((>= (- (-> self clock frame-counter) (-> self last-pillar-hit)) (seconds 2))
+              (process-spawn
+                part-tracker
+                :init part-tracker-init
+                (-> *part-group-id-table* 718)
+                0
+                #f
+                #f
+                self
+                0
+                :to *entity-pool*
+                )
+              (set! (-> self last-pillar-hit) (-> self clock frame-counter))
+              (sound-play "pillar-hit" :position (-> self root-override trans))
+              )
+             )
+           )
+         )
+       )
+      )
+    )
+  :enter (behavior ()
+    (let ((v1-3 (-> (the-as collide-shape-prim-group (-> self root-override root-prim)) child 1)))
+      (set! (-> v1-3 prim-core collide-as) (collide-spec))
+      (set! (-> v1-3 prim-core collide-with) (collide-spec))
+      )
+    0
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :exit (behavior ()
+    (let ((v1-2 (-> self entity extra perm)))
+      (logior! (-> v1-2 status) (entity-perm-status bit-5))
+      (set! (-> v1-2 user-object 1) (-> self segs-shot))
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior tomb-boss-pillar) sleep-code)
+  )
+
+(defmethod deactivate tomb-boss-pillar ((obj tomb-boss-pillar))
+  (if (nonzero? (-> obj explode-part))
+      (kill-and-free-particles (-> obj explode-part))
+      )
+  ((the-as (function process-drawable none) (find-parent-method tomb-boss-pillar 10)) obj)
+  (none)
+  )
+
+;; WARN: Return type mismatch process-drawable vs tomb-boss-pillar.
+(defmethod relocate tomb-boss-pillar ((obj tomb-boss-pillar) (arg0 int))
+  (if (nonzero? (-> obj explode-part))
+      (&+! (-> obj explode-part) arg0)
+      )
+  (the-as
+    tomb-boss-pillar
+    ((the-as (function process-drawable int process-drawable) (find-parent-method tomb-boss-pillar 7)) obj arg0)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! tomb-boss-pillar ((obj tomb-boss-pillar) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (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))
+      (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 0.0 0.0 16384.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (let ((v1-9 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-9 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-9 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-9 prim-core action) (collide-action solid))
+      (set! (-> v1-9 transform-index) 3)
+      (set-vector! (-> v1-9 local-sphere) 0.0 0.0 0.0 16384.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 0.0 0.0 8192.0)
+      )
+    (set! (-> s4-0 nav-radius) 8192.0)
+    (let ((v1-13 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-13 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-13 prim-core collide-with))
+      )
+    (set! (-> obj root-override) (the-as collide-shape-moving s4-0))
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-pillar" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (transform-post)
+  (set! (-> obj explode-part) (create-launch-control (-> *part-group-id-table* 719) obj))
+  (set! (-> obj last-pillar-hit) 0)
+  (let ((v1-23 (-> obj entity extra perm)))
+    (logior! (-> v1-23 status) (entity-perm-status bit-5))
+    (set! (-> obj segs-shot) (the-as int (-> v1-23 user-object 1)))
+    )
+  (damage-pillar)
+  (if (>= (-> obj segs-shot) 16)
+      (go (method-of-object obj broken))
+      (go (method-of-object obj idle))
+      )
+  (none)
+  )
+
+(deftype tomb-boss-firepot (process-drawable)
+  ((root-override collide-shape-moving  :offset 128)
+   )
+  :heap-base #x50
+  :method-count-assert 23
+  :size-assert         #xc8
+  :flag-assert         #x17005000c8
+  (:methods
+    (idle () _type_ :state 20)
+    (break-it () _type_ :state 21)
+    (broken () _type_ :state 22)
+    )
+  )
+
+
+(defskelgroup skel-tomb-boss-firepot tomb-boss-firepot tomb-boss-firepot-lod0-jg tomb-boss-firepot-idle-ja
+              ((tomb-boss-firepot-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 4 0 9)
+              )
+
+(defbehavior tomb-boss-firepot-shrink-collision tomb-boss-firepot ()
+  (let ((v1-1 (the-as collide-shape-prim-group (-> self root-override root-prim))))
+    (let ((a0-1 (-> v1-1 child 0)))
+      (set! (-> a0-1 prim-core collide-as) (collide-spec))
+      (set! (-> a0-1 prim-core collide-with) (collide-spec))
+      )
+    0
+    (let ((v1-3 (-> v1-1 child 1)))
+      (set! (-> v1-3 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-3 prim-core collide-with) (collide-spec jak bot player-list))
+      )
+    )
+  (none)
+  )
+
+(defstate broken (tomb-boss-firepot)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self draw bounds w) 36864.0)
+    (ja :group! (-> self draw art-group data 4)
+        :num! (identity (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 4)) frames num-frames) -1)))
+        )
+    (tomb-boss-firepot-shrink-collision)
+    (ja-post)
+    (none)
+    )
+  :code (the-as (function none :behavior tomb-boss-firepot) sleep-code)
+  )
+
+(defstate break-it (tomb-boss-firepot)
+  :virtual #t
+  :enter (behavior ()
+    (process-entity-status! self (entity-perm-status subtask-complete) #t)
+    (tomb-boss-firepot-shrink-collision)
+    (set! (-> self draw bounds w) 245760.0)
+    (ja :group! (-> self draw art-group data 4) :num! min)
+    (let ((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-4 gp-1)
+              (a1-4 part-tracker-init)
+              (a2-6 (-> *part-group-id-table* 720))
+              (a3-1 0)
+              (t0-0 #f)
+              (t1-0 #f)
+              (t2-0 #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-5)
+           a0-4
+           a1-4
+           a2-6
+           a3-1
+           t0-0
+           t1-0
+           t2-0
+           t3-0
+           )
+          )
+        (-> gp-1 ppointer)
+        )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    (ja :num! (seek!))
+    (if (ja-done? 0)
+        (go-virtual broken)
+        )
+    (none)
+    )
+  :code (the-as (function none :behavior tomb-boss-firepot) sleep-code)
+  :post (the-as (function none :behavior tomb-boss-firepot) ja-post)
+  )
+
+(defstate idle (tomb-boss-firepot)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('attack)
+       (let ((gp-0 proc))
+         (when (if (type? gp-0 widow-shot)
+                   (the-as widow-shot gp-0)
+                   )
+           (let ((v1-2 (the-as object (-> event param 1)))
+                 (gp-1 (new 'stack-no-clear 'vector))
+                 )
+             (cond
+               ((logtest? (attack-info-mask attacker-velocity) (-> (the-as attack-info v1-2) mask))
+                (set! (-> gp-1 quad) (-> (the-as attack-info v1-2) attacker-velocity quad))
+                )
+               (else
+                 (let* ((a3-1 (the-as object (-> event param 0)))
+                        (a1-4 (-> (the-as touching-shapes-entry a3-1) head))
+                        )
+                   (get-intersect-point gp-1 a1-4 (-> self root-override) (the-as touching-shapes-entry a3-1))
+                   )
+                 (vector-! gp-1 (-> self root-override trans) gp-1)
+                 )
+               )
+             (let ((s5-1 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))))
+               (vector-flatten! gp-1 gp-1 (-> s5-1 vector 1))
+               (when (!= (vector-normalize-ret-len! gp-1 1.0) 0.0)
+                 (set! (-> s5-1 vector 2 quad) (-> gp-1 quad))
+                 (vector-cross! (the-as vector (-> s5-1 vector)) (-> s5-1 vector 1) (-> s5-1 vector 2))
+                 (matrix->quaternion (-> self root-override quat) s5-1)
+                 )
+               )
+             )
+           (go-virtual break-it)
+           )
+         )
+       )
+      )
+    )
+  :enter (behavior ()
+    (let ((v1-3 (-> (the-as collide-shape-prim-group (-> self root-override root-prim)) child 1)))
+      (set! (-> v1-3 prim-core collide-as) (collide-spec))
+      (set! (-> v1-3 prim-core collide-with) (collide-spec))
+      )
+    0
+    (none)
+    )
+  :code (the-as (function none :behavior tomb-boss-firepot) sleep-code)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! tomb-boss-firepot ((obj tomb-boss-firepot) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (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))
+      (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) 5)
+      (set-vector! (-> s3-0 local-sphere) 0.0 0.0 0.0 16384.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (let ((v1-9 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-9 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-9 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-9 prim-core action) (collide-action solid))
+      (set! (-> v1-9 transform-index) 5)
+      (set-vector! (-> v1-9 local-sphere) 0.0 0.0 0.0 16384.0)
+      )
+    (let ((v1-11 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (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) 5)
+      (set-vector! (-> v1-11 local-sphere) 0.0 0.0 0.0 16384.0)
+      )
+    (set! (-> s4-0 nav-radius) 8192.0)
+    (let ((v1-13 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-13 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-13 prim-core collide-with))
+      )
+    (set! (-> obj root-override) (the-as collide-shape-moving s4-0))
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-firepot" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj root-override pause-adjust-distance) 245760.0)
+  (transform-post)
+  (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)
+  )
+
+(defmethod draw hud-widow ((obj hud-widow))
+  (set-hud-piece-position! (-> obj sprites 1) (the int (+ 462.0 (* 130.0 (-> obj offset)))) 350)
+  (set-as-offset-from! (the-as hud-sprite (-> obj sprites)) (the-as vector4w (-> obj sprites 1)) -32 0)
+  (set-as-offset-from! (-> obj sprites 5) (the-as vector4w (-> obj sprites 1)) -62 14)
+  (set-as-offset-from! (-> obj sprites 6) (the-as vector4w (-> obj sprites 1)) -32 14)
+  (let ((s5-0 (-> obj values 0 current))
+        (f30-0 (* 0.01 (the float (-> obj values 1 current))))
+        )
+    (set-as-offset-from! (-> obj sprites 4) (the-as vector4w (-> obj sprites 1)) -92 15)
+    (cond
+      ((= s5-0 1)
+       (set! (-> obj sprites 4 color x) 0)
+       (set! (-> obj sprites 4 color y) 255)
+       (set! f30-0 (+ 2.0 f30-0))
+       )
+      ((= s5-0 2)
+       (set! (-> obj sprites 4 color y) 255)
+       (set! (-> obj sprites 4 color x) 255)
+       (set! f30-0 (+ 1.0 f30-0))
+       )
+      ((= s5-0 3)
+       (set! (-> obj sprites 4 color x) 255)
+       (set! (-> obj sprites 4 color y) 0)
+       0
+       )
+      (else
+        (set! f30-0 0.0)
+        )
+      )
+    (set! (-> obj sprites 4 scale-x) (* -7.25 f30-0))
+    )
+  (let ((f30-1 (* 0.01 (the float (-> obj values 2 current)))))
+    (set-as-offset-from! (-> obj sprites 3) (the-as vector4w (-> obj sprites 1)) -84 4)
+    (cond
+      ((< f30-1 0.5)
+       (set! (-> obj sprites 3 color x) 255)
+       (set! (-> obj sprites 3 color y) (the int (lerp 0.0 255.0 (* 2.0 f30-1))))
+       )
+      (else
+        (set! (-> obj sprites 3 color x) (the int (lerp 255.0 0.0 (* 2.0 (+ -0.5 f30-1)))))
+        (set! (-> obj sprites 3 color y) 255)
+        )
+      )
+    (set! (-> obj sprites 3 scale-x) (* -18.25 f30-1))
+    )
+  ((method-of-type hud draw) obj)
+  0
+  (none)
+  )
+
+(defmethod init-callback hud-widow ((obj hud-widow))
+  (set! (-> obj gui-id)
+        (add-process *gui-control* obj (gui-channel hud-middle-right) (gui-action hidden) (-> obj name) 81920.0 0)
+        )
+  (set! (-> obj values 0 target) 1)
+  (set! (-> obj values 1 target) 100)
+  (logior! (-> obj flags) (hud-flags show))
+  (set! (-> obj sprites 0 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x3b :page #x67a)))
+  (set! (-> obj sprites 0 flags) (the-as uint 4))
+  (set! (-> obj sprites 1 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x3c :page #x67a)))
+  (set! (-> obj sprites 1 flags) (the-as uint 4))
+  (set! (-> obj sprites 5 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x3d :page #x67a)))
+  (set! (-> obj sprites 5 scale-x) 0.5)
+  (set! (-> obj sprites 5 flags) (the-as uint 4))
+  (set! (-> obj sprites 6 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x3d :page #x67a)))
+  (set! (-> obj sprites 6 scale-x) 0.5)
+  (set! (-> obj sprites 6 flags) (the-as uint 4))
+  (set! (-> obj sprites 4 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x41 :page #x67a)))
+  (set! (-> obj sprites 4 scale-y) 3.25)
+  (set! (-> obj sprites 4 color z) 0)
+  (set! (-> obj sprites 4 flags) (the-as uint 4))
+  (set! (-> obj sprites 3 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x41 :page #x67a)))
+  (set! (-> obj sprites 3 scale-y) 1.5)
+  (set! (-> obj sprites 3 color z) 0)
+  (set! (-> obj sprites 3 flags) (the-as uint 4))
+  0
+  (none)
+  )
diff --git a/goal_src/jak2/levels/mars_tomb/widow-more-extras.gc b/goal_src/jak2/levels/mars_tomb/widow-more-extras.gc
index e7d50bba7c..a60f7bde14 100644
--- a/goal_src/jak2/levels/mars_tomb/widow-more-extras.gc
+++ b/goal_src/jak2/levels/mars_tomb/widow-more-extras.gc
@@ -7,3 +7,509 @@
 
 ;; DECOMP BEGINS
 
+(deftype tomb-boss-debris (process-drawable)
+  ((root-override collide-shape-moving         :offset        128)
+   (y-velocity    float                        :offset-assert 200)
+   (floor         float                        :offset-assert 204)
+   (sound-floor   float                        :offset-assert 208)
+   (rot           quaternion           :inline :offset-assert 224)
+   (look          int32                        :offset-assert 240)
+   )
+  :heap-base #x80
+  :method-count-assert 22
+  :size-assert         #xf4
+  :flag-assert         #x16008000f4
+  (:methods
+    (die () _type_ :state 20)
+    (idle () _type_ :state 21)
+    )
+  )
+
+
+(defskelgroup skel-tomb-boss-debris-a tomb-boss-debris tomb-boss-debris-a-lod0-jg tomb-boss-debris-a-idle-ja
+              ((tomb-boss-debris-a-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+(defskelgroup skel-tomb-boss-debris-b tomb-boss-debris tomb-boss-debris-b-lod0-jg tomb-boss-debris-b-idle-ja
+              ((tomb-boss-debris-b-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+(defskelgroup skel-tomb-boss-debris-c tomb-boss-debris tomb-boss-debris-c-lod0-jg tomb-boss-debris-c-idle-ja
+              ((tomb-boss-debris-c-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+(defskelgroup skel-tomb-boss-debris-d tomb-boss-debris tomb-boss-debris-d-lod0-jg tomb-boss-debris-d-idle-ja
+              ((tomb-boss-debris-d-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+(defskelgroup skel-tomb-boss-debris-e tomb-boss-debris tomb-boss-debris-e-lod0-jg tomb-boss-debris-e-idle-ja
+              ((tomb-boss-debris-e-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+(defskelgroup skel-tomb-boss-debris-f tomb-boss-debris tomb-boss-debris-f-lod0-jg tomb-boss-debris-f-idle-ja
+              ((tomb-boss-debris-f-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+(defskelgroup skel-tomb-boss-debris-g tomb-boss-debris tomb-boss-debris-g-lod0-jg tomb-boss-debris-g-idle-ja
+              ((tomb-boss-debris-g-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+(defskelgroup skel-tomb-boss-debris-h tomb-boss-debris tomb-boss-debris-h-lod0-jg tomb-boss-debris-h-idle-ja
+              ((tomb-boss-debris-h-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+(defskelgroup skel-tomb-boss-debris-i tomb-boss-debris tomb-boss-debris-i-lod0-jg tomb-boss-debris-i-idle-ja
+              ((tomb-boss-debris-i-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+(defstate die (tomb-boss-debris)
+  :virtual #t
+  :enter (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))
+    (none)
+    )
+  :code (behavior ()
+    (suspend)
+    (suspend)
+    0
+    (none)
+    )
+  )
+
+(defstate idle (tomb-boss-debris)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('touched 'touch 'attack)
+       (let ((v1-2 (-> self look)))
+         (cond
+           ((or (zero? v1-2) (= v1-2 1) (= v1-2 2))
+            (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-8 s5-0)
+                      (a1-7 part-tracker-init)
+                      (a2-5 (-> *part-group-id-table* 734))
+                      (a3-2 5)
+                      (t0-0 #f)
+                      (t1-0 #f)
+                      (t2-0 #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-2)
+                   a0-8
+                   a1-7
+                   a2-5
+                   a3-2
+                   t0-0
+                   t1-0
+                   t2-0
+                   t3-0
+                   )
+                  )
+                (-> s5-0 ppointer)
+                )
+              )
+            (send-event proc 'debris-hit 1)
+            )
+           ((or (= v1-2 3) (= v1-2 4) (= v1-2 5))
+            (let ((s5-1 (get-process *default-dead-pool* part-tracker #x4000)))
+              (when s5-1
+                (let ((t9-5 (method-of-type part-tracker activate)))
+                  (t9-5
+                    (the-as part-tracker s5-1)
+                    *entity-pool*
+                    (symbol->string (-> part-tracker symbol))
+                    (the-as pointer #x70004000)
+                    )
+                  )
+                (let ((t9-6 run-function-in-process)
+                      (a0-16 s5-1)
+                      (a1-13 part-tracker-init)
+                      (a2-10 (-> *part-group-id-table* 735))
+                      (a3-4 5)
+                      (t0-1 #f)
+                      (t1-1 #f)
+                      (t2-1 #f)
+                      (t3-1 *launch-matrix*)
+                      )
+                  (set! (-> t3-1 trans quad) (-> self root-override trans quad))
+                  ((the-as (function object object object object object object object object none) t9-6)
+                   a0-16
+                   a1-13
+                   a2-10
+                   a3-4
+                   t0-1
+                   t1-1
+                   t2-1
+                   t3-1
+                   )
+                  )
+                (-> s5-1 ppointer)
+                )
+              )
+            (send-event proc 'debris-hit 2)
+            )
+           (else
+             (let ((s5-2 (get-process *default-dead-pool* part-tracker #x4000)))
+               (when s5-2
+                 (let ((t9-9 (method-of-type part-tracker activate)))
+                   (t9-9
+                     (the-as part-tracker s5-2)
+                     *entity-pool*
+                     (symbol->string (-> part-tracker symbol))
+                     (the-as pointer #x70004000)
+                     )
+                   )
+                 (let ((t9-10 run-function-in-process)
+                       (a0-21 s5-2)
+                       (a1-17 part-tracker-init)
+                       (a2-15 (-> *part-group-id-table* 736))
+                       (a3-6 5)
+                       (t0-2 #f)
+                       (t1-2 #f)
+                       (t2-2 #f)
+                       (t3-2 *launch-matrix*)
+                       )
+                   (set! (-> t3-2 trans quad) (-> self root-override trans quad))
+                   ((the-as (function object object object object object object object object none) t9-10)
+                    a0-21
+                    a1-17
+                    a2-15
+                    a3-6
+                    t0-2
+                    t1-2
+                    t2-2
+                    t3-2
+                    )
+                   )
+                 (-> s5-2 ppointer)
+                 )
+               )
+             (send-event proc 'debris-hit 3)
+             )
+           )
+         )
+       (go-virtual die)
+       )
+      )
+    )
+  :enter (behavior ()
+    (set! (-> self sound-floor) 81920.0)
+    (none)
+    )
+  :trans (behavior ()
+    (local-vars (sv-16 float))
+    (+! (-> self root-override trans y) (* (-> self y-velocity) (-> self clock time-adjust-ratio)))
+    (set! (-> self y-velocity)
+          (fmax -3686.4 (- (-> self y-velocity) (* 204.8 (-> self clock time-adjust-ratio))))
+          )
+    (if (< (-> self root-override trans y) (-> self floor))
+        (deactivate self)
+        )
+    (when (and (logtest? (-> self draw status) (draw-control-status on-screen))
+               (< (-> self root-override trans y) (+ (-> (camera-pos) y) (-> self sound-floor)))
+               )
+      (sound-play "wid-debris-fall")
+      (set! (-> self sound-floor) -4096000.0)
+      )
+    (quaternion-normalize! (quaternion*! (-> self root-override quat) (-> self rot) (-> self root-override quat)))
+    (let ((f30-1 (lerp-scale 1.0 0.0 (-> self root-override trans y) -368640.0 -442368.0)))
+      (when (< -442368.0 (-> self root-override trans y))
+        (let ((f28-0 (-> *part-id-table* 3266 init-specs 6 initial-valuef))
+              (f26-0 (-> *part-id-table* 3266 init-specs 6 random-rangef))
+              (f24-0 (-> *part-id-table* 3266 init-specs 7 initial-valuef))
+              (f22-0 (-> *part-id-table* 3266 init-specs 7 random-rangef))
+              (f20-0 (-> *part-id-table* 3266 init-specs 8 initial-valuef))
+              )
+          (set! sv-16 (-> *part-id-table* 3266 init-specs 8 random-rangef))
+          (set! (-> *part-id-table* 3266 init-specs 6 initial-valuef)
+                (* (-> *part-id-table* 3266 init-specs 6 initial-valuef) f30-1)
+                )
+          (set! (-> *part-id-table* 3266 init-specs 6 random-rangef)
+                (* (-> *part-id-table* 3266 init-specs 6 random-rangef) f30-1)
+                )
+          (set! (-> *part-id-table* 3266 init-specs 7 initial-valuef)
+                (* (-> *part-id-table* 3266 init-specs 7 initial-valuef) f30-1)
+                )
+          (set! (-> *part-id-table* 3266 init-specs 7 random-rangef)
+                (* (-> *part-id-table* 3266 init-specs 7 random-rangef) f30-1)
+                )
+          (set! (-> *part-id-table* 3266 init-specs 8 initial-valuef)
+                (* (-> *part-id-table* 3266 init-specs 8 initial-valuef) f30-1)
+                )
+          (set! (-> *part-id-table* 3266 init-specs 8 random-rangef)
+                (* (-> *part-id-table* 3266 init-specs 8 random-rangef) f30-1)
+                )
+          (spawn (-> self part) (-> self root-override trans))
+          (set! (-> *part-id-table* 3266 init-specs 6 initial-valuef) f28-0)
+          (set! (-> *part-id-table* 3266 init-specs 6 random-rangef) f26-0)
+          (set! (-> *part-id-table* 3266 init-specs 7 initial-valuef) f24-0)
+          (set! (-> *part-id-table* 3266 init-specs 7 random-rangef) f22-0)
+          (set! (-> *part-id-table* 3266 init-specs 8 initial-valuef) f20-0)
+          )
+        (set! (-> *part-id-table* 3266 init-specs 8 random-rangef) sv-16)
+        sv-16
+        )
+      (set-vector! (-> self draw color-mult) f30-1 f30-1 f30-1 1.0)
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior tomb-boss-debris) sleep-code)
+  :post (behavior ()
+    (transform-post)
+    (let ((a1-0 (new 'stack-no-clear 'overlaps-others-params)))
+      (set! (-> a1-0 options) (overlaps-others-options oo0))
+      (set! (-> a1-0 collide-with-filter) (the-as collide-spec -1))
+      (set! (-> a1-0 tlist) *touching-list*)
+      (find-overlapping-shapes (-> self root-override) a1-0)
+      )
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior tomb-boss-debris-init-by-other tomb-boss-debris ((arg0 vector) (arg1 int))
+  (let ((s4-0 (new 'process 'collide-shape-moving self (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
+                                    generic-attack
+                                    lunge
+                                    flop
+                                    punch
+                                    spin
+                                    roll
+                                    uppercut
+                                    bonk
+                                    tube
+                                    vehicle
+                                    flut-attack
+                                    board
+                                    mech-punch
+                                    dark-punch
+                                    dark-giant
+                                    )
+          )
+    (let ((v1-7 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
+      (set! (-> v1-7 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-7 prim-core collide-with) (collide-spec jak bot enemy hit-by-others-list player-list))
+      (set! (-> v1-7 prim-core action) (collide-action solid))
+      (set-vector! (-> v1-7 local-sphere) 0.0 0.0 0.0 6144.0)
+      (set! (-> s4-0 total-prims) (the-as uint 1))
+      (set! (-> s4-0 root-prim) v1-7)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-10 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-10 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-10 prim-core collide-with))
+      )
+    (set! (-> s4-0 event-self) 'touched)
+    (set! (-> self root-override) s4-0)
+    )
+  (set! (-> self root-override trans quad) (-> arg0 quad))
+  (let ((v1-15 arg1))
+    (cond
+      ((zero? v1-15)
+       (initialize-skeleton
+         self
+         (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-debris-a" (the-as (pointer uint32) #f)))
+         (the-as pair 0)
+         )
+       )
+      ((= v1-15 1)
+       (initialize-skeleton
+         self
+         (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-debris-b" (the-as (pointer uint32) #f)))
+         (the-as pair 0)
+         )
+       )
+      ((= v1-15 2)
+       (set! (-> self root-override root-prim local-sphere w) 5120.0)
+       (initialize-skeleton
+         self
+         (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-debris-c" (the-as (pointer uint32) #f)))
+         (the-as pair 0)
+         )
+       )
+      ((= v1-15 3)
+       (set! (-> self root-override root-prim local-sphere w) 3276.8)
+       (initialize-skeleton
+         self
+         (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-debris-d" (the-as (pointer uint32) #f)))
+         (the-as pair 0)
+         )
+       )
+      ((= v1-15 4)
+       (set! (-> self root-override root-prim local-sphere w) 3276.8)
+       (initialize-skeleton
+         self
+         (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-debris-e" (the-as (pointer uint32) #f)))
+         (the-as pair 0)
+         )
+       )
+      ((= v1-15 5)
+       (set! (-> self root-override root-prim local-sphere w) 4096.0)
+       (initialize-skeleton
+         self
+         (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-debris-f" (the-as (pointer uint32) #f)))
+         (the-as pair 0)
+         )
+       )
+      ((= v1-15 6)
+       (set! (-> self root-override root-prim local-sphere w) 1638.4)
+       (initialize-skeleton
+         self
+         (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-debris-g" (the-as (pointer uint32) #f)))
+         (the-as pair 0)
+         )
+       )
+      ((= v1-15 7)
+       (set! (-> self root-override root-prim local-sphere w) 1638.4)
+       (initialize-skeleton
+         self
+         (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-debris-h" (the-as (pointer uint32) #f)))
+         (the-as pair 0)
+         )
+       )
+      (else
+        (set! (-> self root-override root-prim local-sphere w) 1638.4)
+        (initialize-skeleton
+          self
+          (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-debris-i" (the-as (pointer uint32) #f)))
+          (the-as pair 0)
+          )
+        )
+      )
+    )
+  (set! (-> self look) arg1)
+  (set! (-> self y-velocity) -409.6)
+  (set! (-> self floor) (+ -655360.0 (-> self root-override trans y)))
+  (logclear! (-> self mask) (process-mask actor-pause))
+  (let ((f30-0 (rand-vu-float-range 0.0 65536.0))
+        (f28-0 (rand-vu-float-range 546.13336 1638.4))
+        )
+    (quaternion-axis-angle! (-> self rot) (sin f30-0) 0.0 (cos f30-0) f28-0)
+    )
+  (set! (-> self part) (create-launch-control (-> *part-group-id-table* 733) self))
+  (go-virtual idle)
+  (none)
+  )
+
+(deftype cave-in-master (process-drawable)
+  ((prev-points int32 100 :offset-assert 200)
+   )
+  :heap-base #x1e0
+  :method-count-assert 22
+  :size-assert         #x258
+  :flag-assert         #x1601e00258
+  (:methods
+    (idle () _type_ :state 20)
+    (wait () _type_ :state 21)
+    )
+  )
+
+
+(defbehavior cavein-get-random-point cave-in-master ((arg0 vector))
+  (when (> (-> self path curve num-cverts) 0)
+    (let* ((s5-1 (min 100 (-> self path curve num-cverts)))
+           (v1-5 (rand-vu-int-count s5-1))
+           )
+      (while (> (-> self prev-points v1-5) 0)
+        (+! (-> self prev-points v1-5) -1)
+        (+! v1-5 1)
+        (if (>= v1-5 s5-1)
+            (set! v1-5 (- v1-5 s5-1))
+            )
+        )
+      (set! (-> self prev-points v1-5) 6)
+      (set! (-> arg0 quad) (-> self path curve cverts v1-5 quad))
+      )
+    )
+  arg0
+  )
+
+(defstate idle (cave-in-master)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :trans (behavior ()
+    (spawn (-> self part) (-> self root trans))
+    (when (>= (- (-> self clock frame-counter) (-> self state-time)) 0)
+      (let ((gp-0 (new 'stack-no-clear 'vector)))
+        (cavein-get-random-point gp-0)
+        (set! (-> gp-0 y) (+ 327680.0 (-> gp-0 y)))
+        (process-spawn tomb-boss-debris gp-0 (rand-vu-int-count 8) :to self)
+        )
+      (set! (-> self state-time)
+            (+ (-> self clock frame-counter) (the int (* 300.0 (rand-vu-float-range 0.1 0.5))))
+            )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior cave-in-master) sleep-code)
+  )
+
+(defstate wait (cave-in-master)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('start)
+       (go-virtual idle)
+       )
+      )
+    )
+  :code (the-as (function none :behavior cave-in-master) sleep-code)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! cave-in-master ((obj cave-in-master) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (set! (-> obj root) (new 'process 'trsqv))
+  (process-drawable-from-entity! obj arg0)
+  (set! (-> obj path) (new 'process 'path-control obj 'path 0.0 (the-as entity #f) #f))
+  (if (-> obj path)
+      (logior! (-> obj path flags) (path-control-flag display draw-line draw-point draw-text))
+      )
+  (set! (-> obj root trans y) (+ 327680.0 (-> obj root trans y)))
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (dotimes (v1-12 100)
+    (set! (-> obj prev-points v1-12) 0)
+    )
+  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 737) obj))
+  (go (method-of-object obj wait))
+  (none)
+  )
diff --git a/goal_src/jak2/levels/mars_tomb/widow.gc b/goal_src/jak2/levels/mars_tomb/widow.gc
index 176ce51b10..ebdf125a46 100644
--- a/goal_src/jak2/levels/mars_tomb/widow.gc
+++ b/goal_src/jak2/levels/mars_tomb/widow.gc
@@ -7,3 +7,2228 @@
 
 ;; DECOMP BEGINS
 
+;; WARN: Return type mismatch joint-control-channel vs none.
+(defbehavior widow-common widow ()
+  (update! (-> self theta) 0.0)
+  (widow-rand-vector-method-10 (-> self rand-vec))
+  (widow-oscillator-method-10 (-> self noise-osc) (-> self rand-vec value))
+  (widow-oscillator-method-10 (-> self osc) (the-as vector #f))
+  (widow-float-seeker-method-11 (-> self left-cover-angle) 0.0)
+  (widow-float-seeker-method-11 (-> self right-cover-angle) 0.0)
+  (quaternion-axis-angle!
+    (-> self left-cover-jm quat)
+    1.0
+    0.0
+    0.0
+    (* -16384.0 (-> self left-cover-angle value))
+    )
+  (quaternion-axis-angle!
+    (-> self right-cover-jm quat)
+    1.0
+    0.0
+    0.0
+    (* -16384.0 (-> self right-cover-angle value))
+    )
+  (update! (-> self drill-speed) 0.0)
+  (+! (-> self drill-angle) (* 3495.2534 (-> self drill-speed value)))
+  (quaternion-axis-angle! (-> self left-drill-jm quat) 0.0 1.0 0.0 (-> self drill-angle))
+  (quaternion-axis-angle! (-> self right-drill-jm quat) 0.0 1.0 0.0 (-> self drill-angle))
+  (let ((f30-0 (-> self drill-speed value)))
+    (let ((v1-23 (ja-group)))
+      (if (and (and v1-23 (= v1-23 (-> self draw art-group data 7))) (< 20.0 (ja-aframe-num 0)))
+          (set! f30-0 (lerp-scale 0.0 1.0 (ja-aframe-num 0) 20.0 78.0))
+          )
+      )
+    (let ((v1-32 (ja-group)))
+      (if (and (and v1-32 (= v1-32 (-> self draw art-group data 18))) (< (ja-aframe-num 0) 522.0))
+          (set! f30-0 (lerp-scale 1.0 0.0 (ja-aframe-num 0) 505.0 552.0))
+          )
+      )
+    (cond
+      ((< 0.001 f30-0)
+       (sound-play-by-name
+         (static-sound-name "widow-drill")
+         (the-as sound-id (-> self drill-sound))
+         (the int (* 1024.0 f30-0))
+         (the int (* 1524.0 (* 0.5 (+ -1.0 f30-0))))
+         0
+         (sound-group sfx)
+         (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 11))
+         )
+       (set! (-> self drill-sound-playing) #t)
+       )
+      ((-> self drill-sound-playing)
+       (sound-stop (the-as sound-id (-> self drill-sound)))
+       (set! (-> self drill-sound-playing) #f)
+       )
+      )
+    )
+  (let ((f30-1 (-> self drill-speed value)))
+    (let ((v1-53 (ja-group)))
+      (if (and (and v1-53 (= v1-53 (-> self draw art-group data 7))) (< 77.0 (ja-aframe-num 0)))
+          (set! f30-1 1.0)
+          )
+      )
+    (cond
+      ((< 0.001 f30-1)
+       (sound-play
+         "widow-dril-swtn"
+         :id (the-as sound-id (-> self drill-sweeten-sound))
+         :position (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 11))
+         )
+       (set! (-> self drill-sweeten-sound-playing) #t)
+       )
+      ((-> self drill-sweeten-sound-playing)
+       (sound-stop (the-as sound-id (-> self drill-sweeten-sound)))
+       (set! (-> self drill-sweeten-sound-playing) #f)
+       )
+      )
+    )
+  (cond
+    ((-> self flying)
+     (sound-play-by-name
+       (static-sound-name "widow-hover")
+       (the-as sound-id (-> self hover-sound))
+       (the int (* 1024.0 (lerp-scale 0.5 1.0 (-> self osc value y) -20480.0 -4096.0)))
+       0
+       0
+       (sound-group sfx)
+       (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 3))
+       )
+     (set! (-> self hover-sound-playing) #t)
+     )
+    ((-> self hover-sound-playing)
+     (sound-stop (the-as sound-id (-> self hover-sound)))
+     (set! (-> self hover-sound-playing) #f)
+     )
+    )
+  (let ((v1-81 (ja-group)))
+    (when (or (and v1-81 (or (= v1-81 (-> self draw art-group data 8))
+                             (= v1-81 (-> self draw art-group data 19))
+                             (= v1-81 (-> self draw art-group data 22))
+                             )
+                   )
+              (let ((v1-87 (ja-group)))
+                (and (and v1-87 (= v1-87 (-> self draw art-group data 7))) (< 77.0 (ja-aframe-num 0)))
+                )
+              )
+      (let ((gp-5 (new 'stack-no-clear 'vector)))
+        (when (nonzero? (-> self drill-spark-part))
+          (vector<-cspace! gp-5 (-> self node-list data 11))
+          (vector+float*! gp-5 gp-5 (-> self node-list data 11 bone transform vector 1) 10854.4)
+          (spawn (-> self drill-spark-part) gp-5)
+          )
+        (when (nonzero? (-> self drill-spark-part-alt))
+          (vector<-cspace! gp-5 (-> self node-list data 44))
+          (vector+float*! gp-5 gp-5 (-> self node-list data 44 bone transform vector 1) 10854.4)
+          (spawn (-> self drill-spark-part-alt) gp-5)
+          )
+        )
+      )
+    )
+  (when (and (nonzero? (-> self extract-stone-time))
+             (< (- (-> self clock frame-counter) (-> self extract-stone-time)) (seconds 2))
+             (nonzero? (-> self extract-stone-part))
+             )
+    (let ((gp-6 (new 'stack-no-clear 'vector)))
+      (vector<-cspace! gp-6 (-> self node-list data 44))
+      (spawn (-> self extract-stone-part) gp-6)
+      )
+    )
+  (when (and (nonzero? (-> self insert-stone-time))
+             (< (- (-> self clock frame-counter) (-> self insert-stone-time)) (seconds 2))
+             (nonzero? (-> self insert-stone-part))
+             )
+    (let ((s5-5 (handle->process (-> self pod))))
+      (when s5-5
+        (let ((gp-7 (vector<-cspace! (new 'stack-no-clear 'vector) (-> (the-as process-focusable s5-5) node-list data 4))))
+          (let ((s4-5 (new 'stack-no-clear 'vector)))
+            (vector-matrix*!
+              s4-5
+              (new 'static 'vector :y 4096.0)
+              (-> (the-as process-focusable s5-5) node-list data 4 bone transform)
+              )
+            (vector+! gp-7 gp-7 s4-5)
+            )
+          (spawn (-> self insert-stone-part) gp-7)
+          )
+        )
+      )
+    )
+  (let ((v1-135 (ja-group)))
+    (when (and (and v1-135 (or (= v1-135 (-> self draw art-group data 8))
+                               (= v1-135 (-> self draw art-group data 19))
+                               (= v1-135 (-> self draw art-group data 22))
+                               )
+                    )
+               (zero? (-> self skel float-channels))
+               )
+      (let* ((v1-141 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+             (v1-142 (the-as number (logior #x3f800000 v1-141)))
+             (f0-28 (+ -1.0 (the-as float v1-142)))
+             )
+        (cond
+          ((< f0-28 0.1)
+           (let ((v1-148 (ja-channel-float! (the-as art-joint-anim (-> self draw art-group data 12)) 0.0 0.0 0.0)))
+             (when v1-148
+               (set! (-> self skel interp-select 0) 1016)
+               (set! (-> self skel interp-select 1) 0)
+               (set! (-> v1-148 param 0) 1.0)
+               (set! (-> v1-148 param 1) 0.25)
+               (set! (-> v1-148 param 2) 0.1)
+               (set! (-> v1-148 num-func) num-func-interp1-play!)
+               )
+             )
+           )
+          ((< f0-28 0.2)
+           (let ((v1-153 (ja-channel-float! (the-as art-joint-anim (-> self draw art-group data 13)) 0.0 0.0 0.0)))
+             (when v1-153
+               (set! (-> self skel interp-select 0) 1016)
+               (set! (-> self skel interp-select 1) 0)
+               (set! (-> v1-153 param 0) 1.0)
+               (set! (-> v1-153 param 1) 0.25)
+               (set! (-> v1-153 param 2) 0.1)
+               (set! (-> v1-153 num-func) num-func-interp1-play!)
+               )
+             )
+           )
+          ((< f0-28 0.3)
+           (let ((v1-158 (ja-channel-float! (the-as art-joint-anim (-> self draw art-group data 14)) 0.0 0.0 0.0)))
+             (when v1-158
+               (set! (-> self skel interp-select 0) 1016)
+               (set! (-> self skel interp-select 1) 0)
+               (set! (-> v1-158 param 0) 1.0)
+               (set! (-> v1-158 param 1) 0.25)
+               (set! (-> v1-158 param 2) 0.1)
+               (set! (-> v1-158 num-func) num-func-interp1-play!)
+               )
+             )
+           )
+          ((< f0-28 0.4)
+           (let ((v1-163 (ja-channel-float! (the-as art-joint-anim (-> self draw art-group data 9)) 0.0 0.0 0.0)))
+             (when v1-163
+               (set! (-> self skel interp-select 0) (shl 2032 32))
+               (set! (-> self skel interp-select 1) 0)
+               (set! (-> v1-163 param 0) 1.0)
+               (set! (-> v1-163 param 1) 0.25)
+               (set! (-> v1-163 param 2) 0.1)
+               (set! (-> v1-163 num-func) num-func-interp1-play!)
+               )
+             )
+           )
+          ((< f0-28 0.5)
+           (let ((v1-168 (ja-channel-float! (the-as art-joint-anim (-> self draw art-group data 10)) 0.0 0.0 0.0)))
+             (when v1-168
+               (set! (-> self skel interp-select 0) (shl 2032 32))
+               (set! (-> self skel interp-select 1) 0)
+               (set! (-> v1-168 param 0) 1.0)
+               (set! (-> v1-168 param 1) 0.25)
+               (set! (-> v1-168 param 2) 0.1)
+               (set! (-> v1-168 num-func) num-func-interp1-play!)
+               )
+             )
+           )
+          ((< f0-28 0.6)
+           (let ((v1-172 (ja-channel-float! (the-as art-joint-anim (-> self draw art-group data 11)) 0.0 0.0 0.0)))
+             (when v1-172
+               (set! (-> self skel interp-select 0) (shl 2032 32))
+               (set! (-> self skel interp-select 1) 0)
+               (set! (-> v1-172 param 0) 1.0)
+               (set! (-> v1-172 param 1) 0.25)
+               (set! (-> v1-172 param 2) 0.1)
+               (set! (-> v1-172 num-func) num-func-interp1-play!)
+               )
+             )
+           )
+          )
+        )
+      )
+    )
+  (none)
+  )
+
+(defbehavior widow-calc-position widow ((arg0 vector) (arg1 float) (arg2 float) (arg3 float))
+  (set! (-> arg0 quad) (-> self circle-center quad))
+  (let ((s3-0 (+ 32768.0 arg3)))
+    (+! (-> arg0 x) (* arg1 (sin s3-0)))
+    (+! (-> arg0 y) arg2)
+    (+! (-> arg0 z) (* arg1 (cos s3-0)))
+    )
+  arg0
+  )
+
+(defbehavior widow-calc-target-position widow ((arg0 vector))
+  (let ((s5-1 (vector-! (new 'stack-no-clear 'vector) (-> self circle-center) (target-pos 0))))
+    (set! (-> arg0 x) 184320.0)
+    (set! (-> arg0 y) 10240.0)
+    (set! (-> s5-1 y) 0.0)
+    (vector-normalize! s5-1 1.0)
+    (if (and *target* (< (cos 18204.445) (-> s5-1 z)))
+        (set! (-> arg0 z) (* 11.780972 (fmax -16438.613 (fmin 16438.613 (asin (-> s5-1 x))))))
+        (set! (-> arg0 z) 0.0)
+        )
+    )
+  arg0
+  )
+
+(defbehavior widow-calc-root-from-osc widow ((arg0 float))
+  (let* ((v1-1 (vector+! (new 'stack-no-clear 'vector) (-> self osc value) (-> self noise-osc value)))
+         (f30-0 (* 0.08488264 (-> v1-1 z)))
+         )
+    (widow-calc-position (-> self root trans) (-> v1-1 x) (-> v1-1 y) f30-0)
+    (let* ((f0-4 (+ 32768.0 f30-0))
+           (f30-1 (* 0.5 f0-4))
+           )
+      (quaternion-set! (-> self root quat) 0.0 (sin f30-1) 0.0 (cos f30-1))
+      )
+    )
+  (set! (-> self tilt target) arg0)
+  (update! (-> self tilt) 0.0)
+  (let ((v1-7 (-> self tilt value)))
+    (when (!= v1-7 0.0)
+      (let ((s0-0 (* 0.5 v1-7))
+            (gp-1 (new 'stack-no-clear 'quaternion))
+            )
+        (quaternion-set! gp-1 (sin s0-0) 0.0 0.0 (cos s0-0))
+        (quaternion-normalize! (quaternion*! (-> self root quat) (-> self root quat) gp-1))
+        )
+      )
+    )
+  )
+
+(defbehavior widow-next-pod widow ()
+  (+! (-> self which-pod) 1)
+  (when (>= (-> self which-pod) 12)
+    (set! (-> self which-pod) 0)
+    0
+    )
+  (none)
+  )
+
+;; WARN: Return type mismatch vector vs none.
+(defbehavior widow-pod-position widow ((arg0 vector) (arg1 symbol) (arg2 float))
+  (let ((s4-0 71))
+    (when arg1
+      (set! (-> arg0 x) (- (-> arg0 x)))
+      (set! s4-0 75)
+      )
+    (vector<-cspace! arg0 (-> self node-list data s4-0))
+    (vector-normalize-copy! (the-as vector arg2) (-> self node-list data s4-0 bone transform vector 1) 1638.4)
+    )
+  (none)
+  )
+
+(defbehavior spydroid-setup widow ()
+  (set! (-> self state-time) (+ (-> self clock frame-counter) (seconds -0.247)))
+  (set! (-> self next-launch) -1)
+  (set! (-> self next-jumper) -1)
+  (none)
+  )
+
+(defbehavior widow-bomb-setup widow ()
+  (set! (-> self state-time) (+ (-> self clock frame-counter) (seconds -0.247)))
+  (set! (-> self next-launch) -1)
+  (none)
+  )
+
+(defbehavior spydroid-launch widow ()
+  (when (>= (-> self next-jumper) 0)
+    (if (send-event (handle->process (-> self bomb (-> self next-jumper))) 'jump 2 (-> self launch-dest))
+        (set! (-> self next-jumper) -1)
+        )
+    )
+  (cond
+    ((>= (-> self bomb-hits) 4)
+     0
+     )
+    ((>= (-> self next-launch) 0)
+     (when (and (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.25))
+                (let ((v1-24 (ja-group)))
+                  (not (and v1-24 (= v1-24 (-> self draw art-group data 18))))
+                  )
+                (let ((v1-29 (ja-group)))
+                  (or (not (and v1-29 (or (= v1-29 (-> self draw art-group data 19)) (= v1-29 (-> self draw art-group data 22)))))
+                      (< 12.0 (ja-frame-num 0))
+                      )
+                  )
+                )
+       (let* ((a1-3 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 3)))
+              (gp-1 (< (the int (vector-dot
+                                  (vector-! (new 'stack-no-clear 'vector) (-> self launch-dest) a1-3)
+                                  (the-as vector (-> self node-list data 3 bone transform))
+                                  )
+                            )
+                       0
+                       )
+                    )
+              )
+         (cond
+           (gp-1
+             (set! (-> self left-cover-angle target) 0.0)
+             (set! (-> self right-cover-angle target) 1.0)
+             )
+           (else
+             (set! (-> self left-cover-angle target) 1.0)
+             (set! (-> self right-cover-angle target) 0.0)
+             )
+           )
+         (when (or (and (not gp-1) (< 0.95 (-> self left-cover-angle value)))
+                   (and gp-1 (< 0.95 (-> self right-cover-angle value)))
+                   )
+           (let ((s5-0 (new 'stack-no-clear 'matrix3)))
+             (let ((s4-0 (new 'stack-no-clear 'vector)))
+               (let ((a2-1 (new 'stack-no-clear 'vector)))
+                 (widow-pod-position s4-0 gp-1 (the-as float a2-1))
+                 )
+               (set! (-> s5-0 vector 0 quad) (-> s4-0 quad))
+               )
+             (quaternion-copy! (the-as quaternion (-> s5-0 vector 1)) (-> self root quat))
+             (set! (-> s5-0 vector 2 x) (the-as float (-> self entity)))
+             (set! (-> s5-0 vector 2 y) (the-as float #t))
+             (set! (-> s5-0 vector 2 z) (the-as float #t))
+             (let ((s4-1 (get-process *default-dead-pool* spydroid #x4000)))
+               (set! (-> self bomb (-> self next-launch))
+                     (ppointer->handle (when s4-1
+                                         (let ((t9-6 (method-of-type process activate)))
+                                           (t9-6 s4-1 self (symbol->string (-> spydroid symbol)) (the-as pointer #x70004000))
+                                           )
+                                         (run-now-in-process s4-1 enemy-init-by-other self s5-0)
+                                         (-> s4-1 ppointer)
+                                         )
+                                       )
+                     )
+               )
+             )
+           (when (handle->process (-> self bomb (-> self next-launch)))
+             (if gp-1
+                 (process-spawn
+                   part-tracker
+                   :init part-tracker-init
+                   (-> *part-group-id-table* 721)
+                   300
+                   #f
+                   #f
+                   #f
+                   (-> self node-list data 75 bone transform)
+                   :to *entity-pool*
+                   )
+                 (process-spawn
+                   part-tracker
+                   :init part-tracker-init
+                   (-> *part-group-id-table* 721)
+                   300
+                   #f
+                   #f
+                   #f
+                   (-> self node-list data 71 bone transform)
+                   :to *entity-pool*
+                   )
+                 )
+             (set! (-> self state-time) (-> self clock frame-counter))
+             (let* ((s5-3 (-> self state-time))
+                    (f30-1 75.0)
+                    (v1-89 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                    (v1-90 (the-as number (logior #x3f800000 v1-89)))
+                    )
+               (set! (-> self state-time) (+ s5-3 (the int (* f30-1 (+ -1.0 (the-as float v1-90))))))
+               )
+             (widow-next-pod)
+             (if gp-1
+                 (ja :group! (-> self draw art-group data 22) :num! min)
+                 (ja :group! (-> self draw art-group data 19) :num! min)
+                 )
+             (set! (-> self next-jumper) (-> self next-launch))
+             (set! (-> self next-launch) -1)
+             )
+           )
+         )
+       )
+     1
+     )
+    (else
+      (let ((gp-0 0))
+        (let ((s5-4 (new 'stack-no-clear 'array 'int32 8)))
+          (dotimes (v1-106 7)
+            (when (not (handle->process (-> self bomb v1-106)))
+              (set! (-> s5-4 gp-0) v1-106)
+              (+! gp-0 1)
+              )
+            )
+          (cond
+            ((> gp-0 0)
+             (let* ((v1-110 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                    (v1-111 (the-as number (logior #x3f800000 v1-110)))
+                    )
+               (set! (-> self next-launch)
+                     (-> s5-4 (the int (* (+ -1.0 (the-as float v1-111)) (+ -0.0001 (the float gp-0)))))
+                     )
+               )
+             (let* ((f30-2 184320.0)
+                    (f28-0 8192.0)
+                    (v1-121 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                    (v1-122 (the-as number (logior #x3f800000 v1-121)))
+                    (f30-3 (+ f30-2 (* f28-0 (+ -1.0 (the-as float v1-122)))))
+                    (f28-1 (+ -13289.244 (* 4429.748 (the float (-> self next-launch)))))
+                    (f26-0 -728.1778)
+                    (f24-0 1456.3556)
+                    (v1-130 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                    (v1-131 (the-as number (logior #x3f800000 v1-130)))
+                    (f28-2 (+ f26-0 (* f24-0 (+ -1.0 (the-as float v1-131))) f28-1))
+                    (f30-4 (- f30-3))
+                    )
+               (set-vector! (-> self launch-dest) (* (sin f28-2) f30-4) 0.0 (* (cos f28-2) f30-4) 1.0)
+               )
+             (vector+! (-> self launch-dest) (-> self launch-dest) (-> self circle-center))
+             )
+            (else
+              (set! gp-0 0)
+              )
+            )
+          )
+        gp-0
+        )
+      )
+    )
+  )
+
+(defbehavior widow-bomb-launch widow ((arg0 symbol) (arg1 symbol) (arg2 symbol))
+  (cond
+    ((>= (-> self bomb-hits) 4)
+     0
+     )
+    ((>= (-> self next-launch) 0)
+     (when (and (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.25))
+                (let ((v1-8 (ja-group)))
+                  (not (and v1-8 (= v1-8 (-> self draw art-group data 18))))
+                  )
+                (let ((v1-13 (ja-group)))
+                  (or (not (and v1-13 (or (= v1-13 (-> self draw art-group data 19))
+                                          (= v1-13 (-> self draw art-group data 22))
+                                          (= v1-13 (-> self draw art-group data 32))
+                                          (= v1-13 (-> self draw art-group data 33))
+                                          )
+                                )
+                           )
+                      (< 12.0 (ja-frame-num 0))
+                      )
+                  )
+                )
+       (let* ((a1-5 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 3)))
+              (s4-1 (< (the int (vector-dot
+                                  (vector-! (new 'stack-no-clear 'vector) (-> self launch-dest) a1-5)
+                                  (the-as vector (-> self node-list data 3 bone transform))
+                                  )
+                            )
+                       0
+                       )
+                    )
+              )
+         (cond
+           (s4-1
+             (set! (-> self left-cover-angle target) 0.0)
+             (set! (-> self right-cover-angle target) 1.0)
+             )
+           (else
+             (set! (-> self left-cover-angle target) 1.0)
+             (set! (-> self right-cover-angle target) 0.0)
+             )
+           )
+         (when (or (and (not s4-1) (< 0.95 (-> self left-cover-angle value)))
+                   (and s4-1 (< 0.95 (-> self right-cover-angle value)))
+                   )
+           (let ((s3-0 (new 'stack-no-clear 'vector))
+                 (s2-0 (new 'stack-no-clear 'array 'float 1))
+                 )
+             (widow-pod-position s3-0 s4-1 (the-as float s2-0))
+             (set! (-> self bomb (-> self next-launch))
+                   (ppointer->handle (process-spawn widow-bomb s3-0 (-> self launch-dest) #x43e10000 #x46c00000 s2-0 :to self))
+                   )
+             )
+           (when (handle->process (-> self bomb (-> self next-launch)))
+             (if s4-1
+                 (process-spawn
+                   part-tracker
+                   :init part-tracker-init
+                   (-> *part-group-id-table* 721)
+                   300
+                   #f
+                   #f
+                   #f
+                   (-> self node-list data 75 bone transform)
+                   :to *entity-pool*
+                   )
+                 (process-spawn
+                   part-tracker
+                   :init part-tracker-init
+                   (-> *part-group-id-table* 721)
+                   300
+                   #f
+                   #f
+                   #f
+                   (-> self node-list data 71 bone transform)
+                   :to *entity-pool*
+                   )
+                 )
+             (set! (-> self state-time) (-> self clock frame-counter))
+             (let* ((s3-3 (-> self state-time))
+                    (f30-1 75.0)
+                    (v1-68 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                    (v1-69 (the-as number (logior #x3f800000 v1-68)))
+                    )
+               (set! (-> self state-time) (+ s3-3 (the int (* f30-1 (+ -1.0 (the-as float v1-69))))))
+               )
+             (widow-next-pod)
+             (ja-channel-push! 1 (seconds 0.03))
+             (cond
+               (arg0
+                 (if s4-1
+                     (ja :group! (-> self draw art-group data 35) :num! min)
+                     (ja :group! (-> self draw art-group data 34) :num! min)
+                     )
+                 )
+               (arg1
+                 (if s4-1
+                     (ja :group! (-> self draw art-group data 33) :num! min)
+                     (ja :group! (-> self draw art-group data 32) :num! min)
+                     )
+                 )
+               (s4-1
+                 (ja :group! (-> self draw art-group data 22) :num! min)
+                 )
+               (else
+                 (ja :group! (-> self draw art-group data 19) :num! min)
+                 )
+               )
+             (set! (-> self launched-a-bomb) #t)
+             (set! (-> self next-launch) -1)
+             )
+           )
+         )
+       )
+     1
+     )
+    (else
+      (let ((gp-1 0))
+        (let ((s5-1 (if arg2
+                        8
+                        7
+                        )
+                    )
+              (f30-2 (if arg2
+                         14563.556
+                         13289.244
+                         )
+                     )
+              (s3-4 (new 'stack-no-clear 'array 'int32 8))
+              )
+          (dotimes (v1-106 s5-1)
+            (when (not (handle->process (-> self bomb v1-106)))
+              (set! (-> s3-4 gp-1) v1-106)
+              (+! gp-1 1)
+              )
+            )
+          (cond
+            ((> gp-1 0)
+             (let* ((v1-110 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                    (v1-111 (the-as number (logior #x3f800000 v1-110)))
+                    )
+               (set! (-> self next-launch)
+                     (-> s3-4 (the int (* (+ -1.0 (the-as float v1-111)) (+ -0.0001 (the float gp-1)))))
+                     )
+               )
+             (let* ((f28-0 184320.0)
+                    (f26-0 8192.0)
+                    (v1-121 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                    (v1-122 (the-as number (logior #x3f800000 v1-121)))
+                    (f28-1 (+ f28-0 (* f26-0 (+ -1.0 (the-as float v1-122)))))
+                    (f30-3
+                      (+ (- f30-2) (* (the float (-> self next-launch)) (the float (/ (the int (* 2.0 f30-2)) (+ s5-1 -1)))))
+                      )
+                    (f30-4 (cond
+                             ((not arg2)
+                              (let* ((f26-1 -910.2222)
+                                     (f24-0 1820.4445)
+                                     (v1-131 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                                     (v1-132 (the-as number (logior #x3f800000 v1-131)))
+                                     )
+                                (+ f26-1 (* f24-0 (+ -1.0 (the-as float v1-132))) f30-3)
+                                )
+                              )
+                             ((< (-> self osc value z) (* 11.780972 f30-3))
+                              (+ -728.1778 f30-3)
+                              )
+                             (else
+                               (+ 728.1778 f30-3)
+                               )
+                             )
+                           )
+                    (f28-2 (- f28-1))
+                    )
+               (set-vector! (-> self launch-dest) (* (sin f30-4) f28-2) 0.0 (* (cos f30-4) f28-2) 1.0)
+               )
+             (vector+! (-> self launch-dest) (-> self launch-dest) (-> self circle-center))
+             )
+            (else
+              (set! gp-1 0)
+              )
+            )
+          )
+        gp-1
+        )
+      )
+    )
+  )
+
+;; WARN: Return type mismatch symbol vs none.
+(defbehavior widow-give-ammo widow ()
+  (dotimes (gp-0 2)
+    (cond
+      ((handle->process (-> self ammos gp-0))
+       (set! (-> self ammo-timers gp-0) (-> self clock frame-counter))
+       )
+      ((>= (- (-> self clock frame-counter) (-> self ammo-timers gp-0)) (seconds 20))
+       (let ((s4-0 (new 'static 'fact-info))
+             (s5-0 (new 'stack-no-clear 'vector))
+             )
+         (set! (-> s5-0 quad) (-> self circle-center quad))
+         (let ((s3-0 (new 'stack-no-clear 'vector)))
+           (set-vector! s3-0 0.0 57001.605 -16384.0 1.0)
+           (if (zero? gp-0)
+               (set! (-> s5-0 x) (+ 192512.0 (-> s5-0 x)))
+               (set! (-> s5-0 x) (+ -192512.0 (-> s5-0 x)))
+               )
+           (set! (-> s4-0 options) (actor-option))
+           (set! (-> s4-0 pickup-type) (pickup-type ammo-red))
+           (set! (-> s4-0 pickup-spawn-amount) 20.0)
+           (set! (-> s4-0 fade-time) 0)
+           (set! (-> self ammos gp-0) (ppointer->handle (process-spawn
+                                                          ammo-collectable
+                                                          :init initialize-ammo-by-other
+                                                          s5-0
+                                                          s3-0
+                                                          s4-0
+                                                          :from *pickup-dead-pool*
+                                                          :to self
+                                                          )
+                                                        )
+                 )
+           )
+         )
+       (let ((v1-32 (handle->process (-> self ammos gp-0))))
+         (when v1-32
+           (logclear! (-> (the-as collectable v1-32) flags) (collectable-flag fadeout))
+           (set! (-> self ammo-timers gp-0) (-> self clock frame-counter))
+           )
+         )
+       )
+      )
+    )
+  (none)
+  )
+
+(defbehavior widow-bomb-slots-full widow ()
+  (let ((v0-0 0))
+    (let ((v1-0 (new 'stack-no-clear 'array 'int32 8)))
+      (dotimes (a0-0 8)
+        (when (handle->process (-> self bomb a0-0))
+          (set! (-> v1-0 v0-0) a0-0)
+          (+! v0-0 1)
+          )
+        )
+      )
+    v0-0
+    )
+  )
+
+;; WARN: Return type mismatch symbol vs none.
+(defbehavior widow-debug widow ()
+  (when (and (cpad-hold? 0 r1) (cpad-hold? 0 r2) (cpad-hold? 0 l1) (cpad-hold? 0 l2))
+    (dotimes (gp-0 8)
+      (let ((a0-5 (handle->process (-> self bomb gp-0))))
+        (if a0-5
+            (deactivate a0-5)
+            )
+        )
+      )
+    )
+  (none)
+  )
+
+(if (not *debug-segment*)
+    (set! widow-debug (the-as (function none :behavior widow) nothing))
+    )
+
+;; WARN: Return type mismatch float vs none.
+(defbehavior widow-cleanup-launch-anim widow ((arg0 symbol))
+  (let ((v1-2 (ja-group)))
+    (cond
+      ((and v1-2 (or (= v1-2 (-> self draw art-group data 18))
+                     (= v1-2 (-> self draw art-group data 28))
+                     (= v1-2 (-> self draw art-group data 29))
+                     (= v1-2 (-> self draw art-group data 30))
+                     (= v1-2 (-> self draw art-group data 31))
+                     )
+            )
+       (ja :num! (seek!))
+       (when (ja-done? 0)
+         (let* ((v1-14 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                (v1-15 (the-as number (logior #x3f800000 v1-14)))
+                )
+           (if (or (< (+ -1.0 (the-as float v1-15)) 0.5) (not arg0))
+               (ja :group! (-> self draw art-group data 20) :num! min)
+               (ja :group! (-> self draw art-group data 21) :num! min)
+               )
+           )
+         )
+       )
+      ((let ((v1-30 (ja-group)))
+         (and v1-30 (or (= v1-30 (-> self draw art-group data 20)) (= v1-30 (-> self draw art-group data 21))))
+         )
+       (ja :num! (seek!))
+       (if (ja-done? 0)
+           (ja :group! (-> self draw art-group data 7) :num! (identity 26.0))
+           )
+       )
+      ((let ((v1-48 (ja-group)))
+         (not (and v1-48 (= v1-48 (-> self draw art-group data 8))))
+         )
+       (ja :num! (seek!))
+       (when (ja-done? 0)
+         (ja :group! (-> self draw art-group data 8) :num! min)
+         (set! (-> self drill-speed target) 1.0)
+         (jump-to-target! (-> self drill-speed) 0.0)
+         )
+       )
+      (else
+        (let ((f30-0 (ja-frame-num 0)))
+          (ja :num! (loop!))
+          (cond
+            ((and arg0 (< (ja-frame-num 0) f30-0) (let* ((v1-73 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                                                         (v1-74 (the-as number (logior #x3f800000 v1-73)))
+                                                         )
+                                                    (< (+ -1.0 (the-as float v1-74)) 0.125)
+                                                    )
+                  )
+             (set! (-> self drill-speed target) 0.0)
+             (ja :group! (-> self draw art-group data 18) :num! min)
+             )
+            (else
+              (set! (-> self drill-speed target) 1.0)
+              )
+            )
+          )
+        )
+      )
+    )
+  (none)
+  )
+
+;; WARN: Return type mismatch float vs none.
+(defbehavior widow-last-bomb-anim widow ()
+  (let ((v1-2 (ja-group)))
+    (cond
+      ((and v1-2 (or (= v1-2 (-> self draw art-group data 18))
+                     (= v1-2 (-> self draw art-group data 28))
+                     (= v1-2 (-> self draw art-group data 29))
+                     (= v1-2 (-> self draw art-group data 30))
+                     (= v1-2 (-> self draw art-group data 31))
+                     (= v1-2 (-> self draw art-group data 32))
+                     (= v1-2 (-> self draw art-group data 33))
+                     )
+            )
+       (ja :num! (seek!))
+       (when (ja-done? 0)
+         (let* ((f30-0 2.999)
+                (v1-15 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                (v1-16 (the-as number (logior #x3f800000 v1-15)))
+                (v1-18 (the int (* f30-0 (+ -1.0 (the-as float v1-16)))))
+                )
+           (if (>= v1-18 (-> self previous-anim))
+               (+! v1-18 1)
+               )
+           (set! (-> self previous-anim) v1-18)
+           (cond
+             ((zero? v1-18)
+              (ja :group! (-> self draw art-group data 28) :num! min)
+              )
+             ((= v1-18 1)
+              (ja :group! (-> self draw art-group data 29) :num! min)
+              )
+             ((= v1-18 2)
+              (ja :group! (-> self draw art-group data 30) :num! min)
+              )
+             (else
+               (ja :group! (-> self draw art-group data 31) :num! min)
+               )
+             )
+           )
+         )
+       )
+      (else
+        (ja :num! (seek!))
+        (when (ja-done? 0)
+          (ja :group! (-> self draw art-group data 18) :num! min)
+          (set! (-> self drill-speed target) 0.0)
+          )
+        )
+      )
+    )
+  (none)
+  )
+
+;; WARN: Return type mismatch number vs none.
+(defbehavior widow-flying-anim widow ()
+  (let ((v1-2 (ja-group)))
+    (cond
+      ((and v1-2 (= v1-2 (-> self draw art-group data 5)))
+       (ja :num! (loop!))
+       )
+      (else
+        (ja :num! (seek!))
+        (when (ja-done? 0)
+          (ja :group! (-> self draw art-group data 5) :num! min)
+          (set! (-> self drill-speed target) 0.0)
+          )
+        )
+      )
+    )
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior widow-kaboom-check widow ((arg0 symbol))
+  (if (and arg0
+           (>= (-> self bomb-hits) 4)
+           (or (not *target*) (zero? (logand (-> *target* focus-status) (focus-status dead))))
+           )
+      (go-virtual kaboom)
+      )
+  (if (>= (-> self bomb-hits) 3)
+      (eval!
+        (new 'stack 'script-context (the-as basic (process->ppointer self)) self (the-as vector #f))
+        '(want-anim "tomb-boss-res")
+        )
+      )
+  (none)
+  )
+
+(defstate beaten (widow)
+  :virtual #t
+  :enter (behavior ()
+    (ja-channel-set! 0)
+    (ja-post)
+    (when (-> self hover-sound-playing)
+      (sound-stop (the-as sound-id (-> self hover-sound)))
+      (set! (-> self hover-sound-playing) #f)
+      )
+    (send-event (handle->process (-> self hud)) 'hide-and-die)
+    (none)
+    )
+  :exit (behavior ()
+    (ja-channel-push! 1 0)
+    (ja :group! (-> self draw art-group data 8) :num! min)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  )
+
+(defstate kaboom (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (set-setting! 'music #f 0 0)
+    (dotimes (gp-0 8)
+      (let ((a0-2 (handle->process (-> self bomb gp-0))))
+        (if a0-2
+            (send-event a0-2 'fizzle)
+            )
+        )
+      )
+    (set! (-> self bomb-hits) 0)
+    (set! (-> self flying) #t)
+    (setup-masks (-> self draw) 64 0)
+    (send-event (handle->process (-> self pod)) 'finale)
+    (send-event (ppointer->process (-> self baron)) 'finale)
+    (set! (-> self osc target y) 40960.0)
+    (set! (-> self osc target z) 0.0)
+    (ja-channel-push! 1 (seconds 0.03))
+    (ja :group! (-> self draw art-group data 38) :num! min)
+    (setup-masks (-> self draw) 2 128)
+    (process-grab? *target* #f)
+    (none)
+    )
+  :exit (behavior ()
+    (process-release? *target*)
+    (let ((v1-2 (-> self entity extra perm)))
+      (logior! (-> v1-2 status) (entity-perm-status bit-5))
+      (let ((v0-1 0))
+        (dotimes (a0-3 8)
+          (if (not (handle->process (-> self catwalk a0-3)))
+              (set! v0-1 (logior v0-1 (ash 1 a0-3)))
+              )
+          )
+        (set! (-> v1-2 user-object 1) v0-1)
+        )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    (ja :num! (seek!))
+    (when (ja-done? 0)
+      (process-spawn scene-player :init scene-player-init "tomb-boss-res" #t #f)
+      (remove-setting! 'music)
+      (deactivate (-> self baron 0))
+      (let ((a0-8 (handle->process (-> self pod))))
+        (if a0-8
+            (deactivate a0-8)
+            )
+        )
+      (go-virtual beaten)
+      )
+    (widow-common)
+    (widow-calc-root-from-osc 0.0)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate hover-low-stage-3 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (set! (-> self osc target y) -122880.0)
+    (set! (-> self attack-from-high-deg) (not (-> self attack-from-high-deg)))
+    (set! (-> self flying) #t)
+    (set! (-> self old-bomb-hits) (-> self bomb-hits))
+    (none)
+    )
+  :trans (behavior ()
+    (widow-kaboom-check #t)
+    (if (< (-> self osc value y) (+ 8192.0 (-> self osc target y)))
+        (go-virtual hover-rise-stage-3)
+        )
+    (widow-flying-anim)
+    (widow-common)
+    (widow-calc-root-from-osc 0.0)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate hover-shooting-stage-3 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (widow-shoot-gun-talker)
+    (ja-channel-push! 1 (seconds 0.02))
+    (ja :group! (-> self draw art-group data 15) :num! min)
+    (set! (-> self which-gun) 0)
+    (set! (-> self flying) #t)
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :exit (behavior ()
+    (let ((v1-2 (ja-group)))
+      (if (not (and v1-2 (or (= v1-2 (-> self draw art-group data 38))
+                             (= v1-2 (-> self draw art-group data 37))
+                             (= v1-2 (-> self draw art-group data 36))
+                             )
+                    )
+               )
+          (ja :group! (-> self draw art-group data 17) :num! min)
+          )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    (widow-kaboom-check #t)
+    (if (< (-> self old-bomb-hits) (-> self bomb-hits))
+        (go-virtual hover-low-stage-3)
+        )
+    (let ((a0-3 (widow-calc-target-position (new 'stack-no-clear 'vector)))
+          (v1-5 #t)
+          )
+      (set! (-> self osc target y) (+ -6144.0 (-> a0-3 y)))
+      (cond
+        ((not (-> self attack-from-high-deg))
+         (set! (-> self osc target z) (fmin 193019.44 (+ 21446.604 (-> a0-3 z))))
+         (when (< (+ 2457.6 (-> self osc value z)) (-> self osc target z))
+           (set! (-> self osc target z) (+ 2457.6 (-> self osc value z)))
+           (set! v1-5 #f)
+           )
+         )
+        (else
+          (set! (-> self osc target z)
+                (fmax (fmax -193019.44 (+ -21446.604 (-> a0-3 z))) (+ -2457.6 (-> self osc value z)))
+                )
+          (when (< (-> self osc target z) (+ -2457.6 (-> self osc value z)))
+            (set! (-> self osc target z) (+ -2457.6 (-> self osc value z)))
+            (set! v1-5 #f)
+            )
+          )
+        )
+      (set! v1-5 (and (< (fabs (- (-> self osc value z) (-> self osc target z))) 1024.0)
+                      (and (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.007)) v1-5)
+                      )
+            )
+      (if v1-5
+          (go-virtual hover-low-stage-3)
+          )
+      )
+    (ja :num! (seek!))
+    (let ((v1-22 (ja-group)))
+      (when (and (and v1-22 (= v1-22 (-> self draw art-group data 16)))
+                 (>= (ja-frame-num 0) (the float (-> self which-gun)))
+                 )
+        (let ((v1-28 (-> self which-gun)))
+          (cond
+            ((zero? v1-28)
+             (widow-method-46 self (the-as vector #t) 84)
+             (set! (-> self which-gun) 2)
+             )
+            ((= v1-28 2)
+             (widow-method-46 self (the-as vector #t) 87)
+             (set! (-> self which-gun) 4)
+             )
+            ((= v1-28 4)
+             (widow-method-46 self (the-as vector #t) 82)
+             (set! (-> self which-gun) 6)
+             )
+            ((= v1-28 6)
+             (widow-method-46 self (the-as vector #t) 89)
+             (set! (-> self which-gun) 100)
+             )
+            )
+          )
+        )
+      )
+    (when (ja-done? 0)
+      (ja :group! (-> self draw art-group data 16) :num! min)
+      (set! (-> self which-gun) 0)
+      0
+      )
+    (widow-common)
+    (widow-calc-root-from-osc 0.0)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate hover-launch-bombs-stage-3 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (widow-launch-bombs-talker)
+    (set! (-> self osc target x) 135168.0)
+    (set! (-> self flying) #t)
+    (widow-bomb-setup)
+    (set! (-> self launched-a-bomb) #f)
+    (set! (-> self osc damping) 0.8)
+    (none)
+    )
+  :exit (behavior ()
+    (set! (-> self left-cover-angle target) 0.0)
+    (set! (-> self right-cover-angle target) 0.0)
+    (set! (-> self osc damping) 0.98)
+    (none)
+    )
+  :trans (behavior ()
+    (widow-kaboom-check #t)
+    (if (< (-> self old-bomb-hits) (-> self bomb-hits))
+        (go-virtual hover-low-stage-3)
+        )
+    (widow-flying-anim)
+    (cond
+      ((or (< (widow-bomb-slots-full) 2) (not (-> self launched-a-bomb)))
+       (widow-bomb-launch (-> self flying) #f #t)
+       )
+      ((>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 2.25))
+       (go-virtual hover-shooting-stage-3)
+       )
+      (else
+        (set! (-> self left-cover-angle target) 0.0)
+        (set! (-> self right-cover-angle target) 0.0)
+        )
+      )
+    (let ((v1-15 (widow-calc-target-position (new 'stack-no-clear 'vector))))
+      (set! (-> self osc target y) (-> v1-15 y))
+      (if (-> self attack-from-high-deg)
+          (set! (-> self osc target z) (fmin 193019.44 (+ 42893.207 (-> v1-15 z))))
+          (set! (-> self osc target z) (fmax -193019.44 (+ -42893.207 (-> v1-15 z))))
+          )
+      )
+    (widow-common)
+    (widow-calc-root-from-osc 0.0)
+    (widow-debug)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate hover-big-blast-stage-3 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) 0)
+    (let* ((f0-1 (* 0.08488264 (-> self osc value z)))
+           (v1-2 (max 0 (min 8 (+ (the int (* 0.00024968927 (+ 14017.422 f0-1))) 1))))
+           )
+      (cond
+        ((handle->process (-> self catwalk v1-2))
+         (set! (-> self osc target z) (* 11.780972 (+ -12014.934 (* 4004.9778 (the float (+ v1-2 -1))))))
+         (set! (-> self osc target y) (+ -4096.0 (-> self osc target y)))
+         (set! (-> self targetted-catwalk) v1-2)
+         (widow-stone-charge-up-talker)
+         (set! (-> self stop-catwalk-sound) #t)
+         (set! (-> self catwalk-sound)
+               (the-as uint (add-process *gui-control* self (gui-channel jak) (gui-action queue) "cwlkfall" -99.0 0))
+               )
+         )
+        (else
+          (set! (-> self stop-catwalk-sound) #f)
+          (go-virtual hover-launch-bombs-stage-3)
+          )
+        )
+      )
+    (none)
+    )
+  :exit (behavior ()
+    (dotimes (v1-0 5)
+      (case (-> self lightning v1-0 state mode)
+        (((lightning-mode lm0) (lightning-mode lm3))
+         )
+        (else
+          (let ((a0-7 (-> self lightning v1-0))
+                (a1-2 3)
+                )
+            (let ((a2-1 (!= a1-2 (-> a0-7 state mode))))
+              (case a1-2
+                ((3)
+                 (if a2-1
+                     (set! (-> a0-7 state counter) 0.0)
+                     )
+                 )
+                ((1)
+                 (set! (-> a0-7 state start-color) (-> a0-7 spec start-color))
+                 (set! (-> a0-7 state end-color) (-> a0-7 spec end-color))
+                 )
+                )
+              )
+            (set! (-> a0-7 state mode) (the-as lightning-mode a1-2))
+            )
+          )
+        )
+      )
+    (when (-> self shake-sound-playing)
+      (sound-stop (the-as sound-id (-> self shake-sound)))
+      (set! (-> self shake-sound-playing) #f)
+      )
+    (if (-> self stop-catwalk-sound)
+        (set-action!
+          *gui-control*
+          (gui-action stop)
+          (the-as sound-id (-> self catwalk-sound))
+          (gui-channel none)
+          (gui-action none)
+          (the-as string #f)
+          (the-as (function gui-connection symbol) #f)
+          (the-as process #f)
+          )
+        )
+    (none)
+    )
+  :trans (behavior ()
+    (local-vars (v1-39 symbol) (sv-256 baron-pod) (sv-272 symbol) (sv-288 int) (sv-304 vector) (sv-320 vector))
+    (rlet ((vf0 :class vf)
+           (vf1 :class vf)
+           (vf2 :class vf)
+           )
+      (init-vf0-vector)
+      (widow-kaboom-check #t)
+      (if (< (-> self old-bomb-hits) (-> self bomb-hits))
+          (go-virtual hover-low-stage-3)
+          )
+      (cond
+        ((or (< 4096.0 (fabs (- (-> self osc value z) (-> self osc target z))))
+             (< 4096.0 (fabs (- (-> self osc value y) (-> self osc target y))))
+             )
+         )
+        ((zero? (-> self state-time))
+         (set! (-> self state-time) (-> self clock frame-counter))
+         (sound-play "widow-charge")
+         )
+        ((>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 3))
+         (widow-after-stone-shot-talker)
+         (set! (-> self stop-catwalk-sound) #f)
+         (set-action!
+           *gui-control*
+           (gui-action play)
+           (the-as sound-id (-> self catwalk-sound))
+           (gui-channel none)
+           (gui-action none)
+           (the-as string #f)
+           (the-as (function gui-connection symbol) #f)
+           (the-as process #f)
+           )
+         (set-falloff! *gui-control* (the-as sound-id (-> self catwalk-sound)) #t -1 200 2)
+         (activate! *camera-smush-control* 1228.8 75 270 1.0 0.5 (-> self clock))
+         (send-event (handle->process (-> self catwalk (-> self targetted-catwalk))) 'green-hit)
+         (go-virtual hover-launch-bombs-stage-3)
+         )
+        )
+      (when (and (nonzero? (-> self state-time)) (nonzero? (-> self green-charge-part)))
+        ;; manually rewritten stack var handle->process
+        (if (-> self pod)
+          (set! sv-256 (the-as baron-pod (handle->process (-> self pod))))
+          )
+        (when sv-256
+          (let ((gp-1 (vector<-cspace! (new 'stack-no-clear 'vector) (-> sv-256 node-list data 4))))
+            (cond
+              ((>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 2))
+               (when (-> self shake-sound-playing)
+                 (sound-stop (the-as sound-id (-> self shake-sound)))
+                 (set! (-> self shake-sound-playing) #f)
+                 )
+               )
+              (else
+                (spawn (-> self green-charge-part) gp-1)
+                (sound-play "widow-shake" :id (the-as sound-id (-> self shake-sound)) :position gp-1)
+                (set! (-> self shake-sound-playing) #t)
+                )
+              )
+            (let ((s5-1 (new 'stack-no-clear 'vector))
+                  (s4-0 (new 'stack-no-clear 'vector))
+                  (s3-0 (new 'stack-no-clear 'vector))
+                  (s2-0 (new 'stack-no-clear 'vector))
+                  (s1-0 (new 'stack-no-clear 'vector))
+                  (s0-0 (new 'stack-no-clear 'matrix))
+                  )
+              (vector-normalize-copy! s2-0 (-> sv-256 node-list data 4 bone transform vector 1) 1.0)
+              (vector-float*! s5-1 s2-0 61440.0)
+              (vector+! s5-1 s5-1 gp-1)
+              (vector-! s1-0 s5-1 gp-1)
+              (vector-normalize! s1-0 1.0)
+              (matrix-axis-angle! s0-0 s1-0 13107.2)
+              (vector-reset! (-> s0-0 trans))
+              (set-vector! s4-0 (-> s1-0 z) 0.0 (- (-> s1-0 x)) 1.0)
+              (vector-normalize! s4-0 409.6)
+              (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 2))
+                (set! sv-272 (the-as symbol #f))
+                (set! sv-288 0)
+                (while (< sv-288 5)
+                  (case (-> self lightning sv-288 state mode)
+                    (((lightning-mode lm0) (lightning-mode lm3))
+                     (let ((v1-78 (-> self lightning sv-288))
+                           (a0-35 1)
+                           )
+                       (let ((a1-19 (!= a0-35 (-> v1-78 state mode))))
+                         (case a0-35
+                           ((3)
+                            (if a1-19
+                                (set! (-> v1-78 state counter) 0.0)
+                                )
+                            )
+                           ((1)
+                            (set! (-> v1-78 state start-color) (-> v1-78 spec start-color))
+                            (set! (-> v1-78 state end-color) (-> v1-78 spec end-color))
+                            )
+                           )
+                         )
+                       (set! (-> v1-78 state mode) (the-as lightning-mode a0-35))
+                       )
+                     (set! sv-272 #t)
+                     sv-272
+                     )
+                    )
+                  (vector-matrix*! s4-0 s4-0 s0-0)
+                  (vector+! s1-0 s4-0 gp-1)
+                  (let ((a0-38 (-> self lightning sv-288))
+                        (v1-85 s1-0)
+                        )
+                    (set! (-> a0-38 state meet data 0 quad) (-> v1-85 quad))
+                    )
+                  (set! sv-320 s3-0)
+                  (set! sv-304 s2-0)
+                  (let ((f0-9 (rand-vu-float-range -8192.0 8192.0)))
+                    (.lvf vf1 (&-> sv-304 quad))
+                    (let ((v1-88 f0-9))
+                      (.mov vf2 v1-88)
+                      )
+                    )
+                  (.add.x.vf vf1 vf0 vf0 :mask #b1000)
+                  (.mul.x.vf vf1 vf1 vf2 :mask #b111)
+                  (.svf (&-> sv-320 quad) vf1)
+                  (vector+! s3-0 s3-0 s5-1)
+                  (let ((a0-43 (-> self lightning sv-288))
+                        (v1-94 s3-0)
+                        )
+                    (set! (-> a0-43 state meet data (+ (-> a0-43 state points-to-draw) -1) quad) (-> v1-94 quad))
+                    )
+                  (set! sv-288 (+ sv-288 1))
+                  )
+                (if sv-272
+                    (sound-play "widow-lightning" :position gp-1)
+                    )
+                )
+              )
+            )
+          )
+        )
+      (widow-flying-anim)
+      (widow-common)
+      (widow-calc-root-from-osc 1820.4445)
+      (widow-debug)
+      (none)
+      )
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate hover-rise-stage-3 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (set! (-> self osc target x) 135168.0)
+    (set! (-> self flying) #t)
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self osc damping) 0.9)
+    (set! (-> self old-bomb-hits) (-> self bomb-hits))
+    (none)
+    )
+  :trans (behavior ()
+    (widow-general-flying-talker)
+    (widow-kaboom-check #t)
+    (let ((gp-0 (widow-calc-target-position (new 'stack-no-clear 'vector))))
+      (set! (-> self osc target y) (-> gp-0 y))
+      (when (< (+ -10240.0 (-> self osc target y)) (-> self osc value y))
+        (if (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.007))
+            (go-virtual hover-big-blast-stage-3)
+            )
+        )
+      (if (-> self attack-from-high-deg)
+          (set! (-> self osc target z) (fmin 193019.44 (+ 42893.207 (-> gp-0 z))))
+          (set! (-> self osc target z) (fmax -193019.44 (+ -42893.207 (-> gp-0 z))))
+          )
+      )
+    (widow-flying-anim)
+    (widow-common)
+    (widow-calc-root-from-osc 0.0)
+    (widow-debug)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate hover-seek-under-stage-3 (widow)
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (set! (-> self osc target x) 135168.0)
+    (set! (-> self flying) #t)
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :trans (behavior ()
+    (widow-kaboom-check #f)
+    (let ((v1-0 (widow-calc-target-position (new 'stack-no-clear 'vector))))
+      (if (-> self attack-from-high-deg)
+          (set! (-> self osc target z) (fmin 193019.44 (+ 42893.207 (-> v1-0 z))))
+          (set! (-> self osc target z) (fmax -193019.44 (+ -42893.207 (-> v1-0 z))))
+          )
+      )
+    (if (and (< (fabs (- (-> self osc value z) (-> self osc target z))) 8192.0)
+             (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.007))
+             )
+        (go-virtual hover-rise-stage-3)
+        )
+    (ja :num! (loop!))
+    (widow-common)
+    (widow-calc-root-from-osc 0.0)
+    (widow-debug)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate hover-jump-down-stage-3 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (widow-leave-perch-talker)
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (ja-channel-push! 1 (seconds 1.5))
+    (ja :group! (-> self draw art-group data 5) :num! min)
+    (let ((gp-1 (widow-calc-target-position (new 'stack-no-clear 'vector))))
+      (set! (-> self theta max-vel) 91.022224)
+      (set! (-> self theta accel) 0.01)
+      (set! (-> self theta target) (* 0.08488264 (-> gp-1 z)))
+      (widow-calc-position gp-1 151552.0 -81920.0 (-> self theta target))
+      (setup-from-to-duration-and-height! (-> self traj) (-> self root trans) gp-1 450.0 49152.0)
+      )
+    (set! (-> self flying) #t)
+    (none)
+    )
+  :exit (behavior ()
+    (let ((a1-0 (new 'stack-no-clear 'vector)))
+      (set-vector! a1-0 151552.0 -81920.0 (* 11.780972 (-> self theta target)) 1.0)
+      (widow-oscillator-method-9 (-> self osc) a1-0 81.92 1638.4 0.98)
+      )
+    (widow-oscillator-method-9 (-> self noise-osc) (the-as vector #f) 4.096 204.8 0.9)
+    (init (-> self rand-vec) 75 150 204.8 819.2)
+    (none)
+    )
+  :trans (behavior ()
+    (widow-kaboom-check #f)
+    (ja :num! (loop!))
+    (compute-trans-at-time
+      (-> self traj)
+      (the float (min 450 (- (-> self clock frame-counter) (-> self state-time))))
+      (-> self root trans)
+      )
+    (if (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1.5))
+        (go hover-seek-under-stage-3)
+        )
+    (quaternion-axis-angle! (-> self root quat) 0.0 1.0 0.0 (+ 32768.0 (-> self theta value)))
+    (widow-common)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate big-reaction-stage-2 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (talker-spawn-func (-> *talker-speech* 302) *entity-pool* (target-pos 0) (the-as region #f))
+    (dotimes (gp-1 8)
+      (let ((a0-3 (handle->process (-> self bomb gp-1))))
+        (if a0-3
+            (send-event a0-3 'fizzle)
+            )
+        )
+      )
+    (set! (-> self bomb-hits) 0)
+    (set! (-> self drill-speed target) 0.0)
+    (set! (-> self flying) #f)
+    (ja-channel-push! 1 (seconds 0.02))
+    (ja :group! (-> self draw art-group data 4) :num! min)
+    (set! (-> self extract-stone-time) (-> self clock frame-counter))
+    (none)
+    )
+  :exit (behavior ()
+    (send-event (handle->process (-> self pod)) 'grab-done)
+    (send-event (ppointer->process (-> self baron)) 'grab-done)
+    (send-event (handle->process (-> self heart)) 'grab-done)
+    (let ((v1-18 (handle->process (-> self hud))))
+      (when v1-18
+        (set! (-> (the-as hud-widow v1-18) values 0 target) 3)
+        (set! (-> (the-as hud-widow v1-18) values 1 target) 100)
+        )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    (ja :num! (seek!))
+    (let ((f30-0 (ja-aframe-num 0)))
+      (send-event (handle->process (-> self pod)) 'frame f30-0)
+      (send-event (ppointer->process (-> self baron)) 'frame f30-0)
+      (send-event (handle->process (-> self heart)) 'frame f30-0)
+      (if (and (zero? (-> self insert-stone-time)) (>= f30-0 827.0))
+          (set! (-> self insert-stone-time) (-> self clock frame-counter))
+          )
+      )
+    (if (ja-done? 0)
+        (go-virtual hover-jump-down-stage-3)
+        )
+    (widow-common)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate watch-bombs-stage-2 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (set! (-> self flying) #f)
+    (none)
+    )
+  :trans (behavior ()
+    (widow-want-stone-talker)
+    (let ((gp-0 (widow-bomb-slots-full)))
+      (cond
+        ((>= (-> self bomb-hits) 4)
+         (go-virtual big-reaction-stage-2)
+         )
+        ((and (zero? gp-0) (let ((v1-8 (ja-group)))
+                             (and v1-8 (= v1-8 (-> self draw art-group data 8)))
+                             )
+              )
+         (go-virtual launch-droids-stage-2)
+         )
+        )
+      (if (and (>= (-> self bomb-hits) 3) (nonzero? gp-0))
+          (widow-last-bomb-anim)
+          (widow-cleanup-launch-anim (< 3 gp-0))
+          )
+      )
+    (widow-give-ammo)
+    (widow-common)
+    (widow-debug)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate launch-bombs-stage-2 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (widow-launch-bombs-talker)
+    (widow-bomb-setup)
+    (set! (-> self flying) #f)
+    (none)
+    )
+  :exit (behavior ()
+    (set! (-> self left-cover-angle target) 0.0)
+    (set! (-> self right-cover-angle target) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (if (>= (-> self bomb-hits) 3)
+        (widow-last-bomb-anim)
+        (widow-cleanup-launch-anim #f)
+        )
+    (if (zero? (widow-bomb-launch (-> self flying) (>= (-> self bomb-hits) 3) #f))
+        (go-virtual watch-bombs-stage-2)
+        )
+    (widow-give-ammo)
+    (widow-common)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate back-to-perch-stage-2 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (ja-channel-push! 1 (seconds 1))
+    (ja :group! (-> self draw art-group data 6) :num! min)
+    (let ((a2-1 (new 'stack-no-clear 'vector))
+          (f0-1 49152.0)
+          )
+      (set! (-> a2-1 quad) (-> self circle-center quad))
+      (set! (-> a2-1 z) (+ -40960.0 (-> a2-1 z)))
+      (let ((f0-3 (- (+ f0-1 (-> a2-1 y)) (-> self root trans y))))
+        (setup-from-to-duration-and-height! (-> self traj) (-> self root trans) a2-1 300.0 f0-3)
+        )
+      )
+    (set! (-> self theta max-vel) 273.06668)
+    (set! (-> self theta accel) 0.05)
+    (set! (-> self theta target) 0.0)
+    (set! (-> self theta vel) (* 0.08488264 (-> self osc vel z)))
+    (set! (-> self theta value) (* 0.08488264 (-> self osc value z)))
+    (set! (-> self flying) #t)
+    (none)
+    )
+  :trans (behavior ()
+    (compute-trans-at-time
+      (-> self traj)
+      (the float (min 300 (- (-> self clock frame-counter) (-> self state-time))))
+      (-> self root trans)
+      )
+    (quaternion-axis-angle! (-> self root quat) 0.0 1.0 0.0 (+ 32768.0 (-> self theta value)))
+    (let ((v1-9 (ja-group)))
+      (cond
+        ((and v1-9 (= v1-9 (-> self draw art-group data 6)))
+         (ja :num! (seek!))
+         (when (and (ja-done? 0) (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1)))
+           (ja-channel-push! 1 (seconds 0.02))
+           (ja :group! (-> self draw art-group data 7) :num! min)
+           (set! (-> self flying) #f)
+           (when (nonzero? (-> self land-part))
+             (let ((gp-1 (new 'stack-no-clear 'vector)))
+               (vector<-cspace! gp-1 (-> self node-list data 28))
+               (spawn (-> self land-part) gp-1)
+               (vector<-cspace! gp-1 (-> self node-list data 36))
+               (spawn (-> self land-part) gp-1)
+               (vector<-cspace! gp-1 (-> self node-list data 61))
+               (spawn (-> self land-part) gp-1)
+               (vector<-cspace! gp-1 (-> self node-list data 69))
+               (spawn (-> self land-part) gp-1)
+               )
+             )
+           )
+         )
+        ((let ((v1-47 (ja-group)))
+           (and v1-47 (= v1-47 (-> self draw art-group data 7)))
+           )
+         (ja :num! (seek!))
+         (when (ja-done? 0)
+           (set! (-> self drill-speed target) 1.0)
+           (jump-to-target! (-> self drill-speed) 0.0)
+           (go-virtual launch-bombs-stage-2)
+           )
+         )
+        )
+      )
+    (widow-give-ammo)
+    (widow-common)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate hover-low-stage-2 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (set! (-> self osc target y) -122880.0)
+    (let* ((v1-2 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+           (v1-3 (the-as number (logior #x3f800000 v1-2)))
+           )
+      (if (< (+ -1.0 (the-as float v1-3)) 0.5)
+          (set! (-> self attack-from-high-deg) (not (-> self attack-from-high-deg)))
+          )
+      )
+    (set! (-> self flying) #t)
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :trans (behavior ()
+    (widow-general-flying-talker)
+    (if (>= (-> self bomb-hits) 4)
+        (go-virtual back-to-perch-stage-2)
+        )
+    (when (< (-> self osc value y) (+ 8192.0 (-> self osc target y)))
+      (cond
+        ((zero? (widow-bomb-slots-full))
+         (go-virtual back-to-perch-stage-2)
+         )
+        ((>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.007))
+         (go-virtual hover-seek-under-stage-2)
+         )
+        )
+      )
+    (let ((v1-20 (ja-group)))
+      (cond
+        ((and v1-20 (= v1-20 (-> self draw art-group data 17)))
+         (ja :num! (seek!))
+         (if (ja-done? 0)
+             (ja :group! (-> self draw art-group data 5) :num! min)
+             )
+         )
+        (else
+          (ja :num! (loop!))
+          )
+        )
+      )
+    (widow-give-ammo)
+    (widow-common)
+    (widow-calc-root-from-osc 0.0)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate hover-shooting-stage-2 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (widow-shoot-gun-talker)
+    (ja-channel-push! 1 (seconds 0.02))
+    (ja :group! (-> self draw art-group data 15) :num! min)
+    (set! (-> self which-gun) 0)
+    (set! (-> self flying) #t)
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (+! (-> self current-shoot-stage) 1)
+    (none)
+    )
+  :exit (behavior ()
+    (ja :group! (-> self draw art-group data 17) :num! min)
+    (if (and (< 1 (-> self gun-hits)) (< (-> self current-shoot-stage) 10))
+        (talker-spawn-func (-> *talker-speech* 301) *entity-pool* (target-pos 0) (the-as region #f))
+        )
+    (none)
+    )
+  :trans (behavior ()
+    (if (>= (-> self bomb-hits) 4)
+        (go-virtual back-to-perch-stage-2)
+        )
+    (let ((a0-1 (widow-calc-target-position (new 'stack-no-clear 'vector)))
+          (v1-5 #t)
+          )
+      (set! (-> self osc target y) (-> a0-1 y))
+      (cond
+        ((not (-> self attack-from-high-deg))
+         (set! (-> self osc target z) (fmin 193019.44 (+ 21446.604 (-> a0-1 z))))
+         (when (< (+ 2457.6 (-> self osc value z)) (-> self osc target z))
+           (set! (-> self osc target z) (+ 2457.6 (-> self osc value z)))
+           (set! v1-5 #f)
+           )
+         )
+        (else
+          (set! (-> self osc target z)
+                (fmax (fmax -193019.44 (+ -21446.604 (-> a0-1 z))) (+ -2457.6 (-> self osc value z)))
+                )
+          (when (< (-> self osc target z) (+ -2457.6 (-> self osc value z)))
+            (set! (-> self osc target z) (+ -2457.6 (-> self osc value z)))
+            (set! v1-5 #f)
+            )
+          )
+        )
+      (set! v1-5 (and (< (fabs (- (-> self osc value z) (-> self osc target z))) 1024.0)
+                      (and (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.007)) v1-5)
+                      )
+            )
+      (if v1-5
+          (go-virtual hover-low-stage-2)
+          )
+      )
+    (ja :num! (seek!))
+    (let ((v1-22 (ja-group)))
+      (when (and (and v1-22 (= v1-22 (-> self draw art-group data 16)))
+                 (>= (ja-frame-num 0) (the float (-> self which-gun)))
+                 )
+        (let ((v1-28 (-> self which-gun)))
+          (cond
+            ((zero? v1-28)
+             (widow-method-46 self (the-as vector #t) 84)
+             (set! (-> self which-gun) 2)
+             )
+            ((= v1-28 2)
+             (widow-method-46 self (the-as vector #t) 87)
+             (set! (-> self which-gun) 4)
+             )
+            ((= v1-28 4)
+             (widow-method-46 self (the-as vector #t) 82)
+             (set! (-> self which-gun) 6)
+             )
+            ((= v1-28 6)
+             (widow-method-46 self (the-as vector #t) 89)
+             (set! (-> self which-gun) 100)
+             )
+            )
+          )
+        )
+      )
+    (when (ja-done? 0)
+      (ja :group! (-> self draw art-group data 16) :num! min)
+      (set! (-> self which-gun) 0)
+      0
+      )
+    (widow-give-ammo)
+    (widow-common)
+    (widow-calc-root-from-osc 0.0)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate hover-rise-stage-2 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (set! (-> self osc target x) 135168.0)
+    (set! (-> self flying) #t)
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :trans (behavior ()
+    (if (>= (-> self bomb-hits) 4)
+        (go-virtual back-to-perch-stage-2)
+        )
+    (let ((gp-0 (widow-calc-target-position (new 'stack-no-clear 'vector))))
+      (set! (-> self osc target y) (-> gp-0 y))
+      (when (and (< (+ -10240.0 (-> self osc target y)) (-> self osc value y))
+                 (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.007))
+                 )
+        (let* ((v1-13 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+               (v1-14 (the-as number (logior #x3f800000 v1-13)))
+               )
+          (if (< (+ -1.0 (the-as float v1-14)) 0.1)
+              (go-virtual hover-low-stage-2)
+              (go-virtual hover-shooting-stage-2)
+              )
+          )
+        )
+      (if (-> self attack-from-high-deg)
+          (set! (-> self osc target z) (fmin 193019.44 (+ 42893.207 (-> gp-0 z))))
+          (set! (-> self osc target z) (fmax -193019.44 (+ -42893.207 (-> gp-0 z))))
+          )
+      )
+    (widow-flying-anim)
+    (widow-give-ammo)
+    (widow-common)
+    (widow-calc-root-from-osc 0.0)
+    (widow-debug)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate hover-seek-under-stage-2 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (set! (-> self osc target x) 135168.0)
+    (set! (-> self flying) #t)
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :trans (behavior ()
+    (if (>= (-> self bomb-hits) 4)
+        (go-virtual back-to-perch-stage-2)
+        )
+    (widow-general-flying-talker)
+    (let ((v1-5 (widow-calc-target-position (new 'stack-no-clear 'vector))))
+      (if (-> self attack-from-high-deg)
+          (set! (-> self osc target z) (fmin 193019.44 (+ 42893.207 (-> v1-5 z))))
+          (set! (-> self osc target z) (fmax -193019.44 (+ -42893.207 (-> v1-5 z))))
+          )
+      )
+    (if (and (< (fabs (- (-> self osc value z) (-> self osc target z))) 8192.0)
+             (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.007))
+             )
+        (go-virtual hover-rise-stage-2)
+        )
+    (widow-flying-anim)
+    (widow-give-ammo)
+    (widow-common)
+    (widow-calc-root-from-osc 0.0)
+    (widow-debug)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate hover-jump-down-stage-2 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (widow-leave-perch-talker)
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self drill-speed target) 0.0)
+    (ja-channel-push! 1 (seconds 1.5))
+    (ja :group! (-> self draw art-group data 5) :num! min)
+    (let ((gp-1 (widow-calc-target-position (new 'stack-no-clear 'vector))))
+      (set! (-> self theta target) (* 0.08488264 (-> gp-1 z)))
+      (widow-calc-position gp-1 151552.0 -81920.0 (-> self theta target))
+      (setup-from-to-duration-and-height! (-> self traj) (-> self root trans) gp-1 450.0 49152.0)
+      )
+    (set! (-> self flying) #t)
+    (none)
+    )
+  :exit (behavior ()
+    (let ((a1-0 (new 'stack-no-clear 'vector)))
+      (set-vector! a1-0 151552.0 -81920.0 (* 11.780972 (-> self theta target)) 1.0)
+      (widow-oscillator-method-9 (-> self osc) a1-0 81.92 1638.4 0.98)
+      )
+    (widow-oscillator-method-9 (-> self noise-osc) (the-as vector #f) 4.096 204.8 0.9)
+    (init (-> self rand-vec) 75 150 204.8 819.2)
+    (none)
+    )
+  :trans (behavior ()
+    (widow-flying-anim)
+    (compute-trans-at-time
+      (-> self traj)
+      (the float (min 450 (- (-> self clock frame-counter) (-> self state-time))))
+      (-> self root trans)
+      )
+    (if (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1.5))
+        (go-virtual hover-seek-under-stage-2)
+        )
+    (quaternion-axis-angle! (-> self root quat) 0.0 1.0 0.0 (+ 32768.0 (-> self theta value)))
+    (widow-give-ammo)
+    (widow-common)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate launch-droids-stage-2 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (widow-launch-droids-talker)
+    (spydroid-setup)
+    (set! (-> self flying) #f)
+    (none)
+    )
+  :exit (behavior ()
+    (set! (-> self left-cover-angle target) 0.0)
+    (set! (-> self right-cover-angle target) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (widow-cleanup-launch-anim #f)
+    (if (>= (-> self bomb-hits) 4)
+        (go-virtual launch-bombs-stage-2)
+        )
+    (if (zero? (spydroid-launch))
+        (go-virtual hover-jump-down-stage-2)
+        )
+    (widow-give-ammo)
+    (widow-common)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate big-reaction-stage-1 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (dotimes (gp-0 8)
+      (let ((a0-1 (handle->process (-> self bomb gp-0))))
+        (if a0-1
+            (send-event a0-1 'fizzle)
+            )
+        )
+      )
+    (set! (-> self bomb-hits) 0)
+    (set! (-> self drill-speed target) 0.0)
+    (set! (-> self flying) #f)
+    (ja-channel-push! 1 (seconds 0.02))
+    (ja :group! (-> self draw art-group data 25) :num! min)
+    (none)
+    )
+  :exit (behavior ()
+    (let ((v1-1 (handle->process (-> self hud))))
+      (when v1-1
+        (set! (-> (the-as hud-widow v1-1) values 0 target) 2)
+        (set! (-> (the-as hud-widow v1-1) values 1 target) 100)
+        )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    (let ((v1-2 (ja-group)))
+      (if (and (and v1-2 (= v1-2 (-> self draw art-group data 8))) (zero? (widow-bomb-slots-full)))
+          (go-virtual launch-droids-stage-2)
+          )
+      )
+    (ja :num! (seek!))
+    (when (ja-done? 0)
+      (ja :group! (-> self draw art-group data 8) :num! min)
+      (set! (-> self drill-speed target) 1.0)
+      )
+    (widow-give-ammo)
+    (widow-common)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate watch-bombs-stage-1 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (set! (-> self flying) #f)
+    (none)
+    )
+  :trans (behavior ()
+    (widow-want-stone-talker)
+    (let ((gp-0 (widow-bomb-slots-full)))
+      (cond
+        ((>= (-> self bomb-hits) 4)
+         (go-virtual big-reaction-stage-1)
+         )
+        ((and (zero? gp-0) (let ((v1-8 (ja-group)))
+                             (and v1-8 (= v1-8 (-> self draw art-group data 8)))
+                             )
+              )
+         (go-virtual launch-droids-stage-1)
+         )
+        )
+      (widow-cleanup-launch-anim (< 3 gp-0))
+      )
+    (widow-give-ammo)
+    (widow-common)
+    (widow-debug)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate launch-bombs-stage-1 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (if (and (< (-> self kicked-bombs) 2) (>= (-> self launch-stages-completed) 1))
+        (talker-spawn-func (-> *talker-speech* 303) *entity-pool* (target-pos 0) (the-as region #f))
+        (widow-launch-bombs-talker)
+        )
+    (widow-bomb-setup)
+    (set! (-> self flying) #f)
+    (none)
+    )
+  :exit (behavior ()
+    (set! (-> self left-cover-angle target) 0.0)
+    (set! (-> self right-cover-angle target) 0.0)
+    (+! (-> self launch-stages-completed) 1)
+    (none)
+    )
+  :trans (behavior ()
+    (widow-cleanup-launch-anim #f)
+    (if (zero? (widow-bomb-launch (-> self flying) #f #f))
+        (go-virtual watch-bombs-stage-1)
+        )
+    (widow-give-ammo)
+    (widow-common)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate watch-droids-stage-1 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (set! (-> self flying) #f)
+    (none)
+    )
+  :trans (behavior ()
+    (widow-want-stone-talker)
+    (if (>= (-> self bomb-hits) 4)
+        (go-virtual big-reaction-stage-1)
+        )
+    (let ((gp-0 (widow-bomb-slots-full)))
+      (if (and (zero? gp-0) (let ((v1-8 (ja-group)))
+                              (and v1-8 (= v1-8 (-> self draw art-group data 8)))
+                              )
+               )
+          (go-virtual launch-bombs-stage-1)
+          )
+      (widow-cleanup-launch-anim (< 3 gp-0))
+      )
+    (widow-give-ammo)
+    (widow-common)
+    (widow-debug)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate launch-droids-stage-1 (widow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow) widow-handler)
+  :enter (behavior ()
+    (widow-launch-droids-talker)
+    (let ((gp-0 (new 'stack-no-clear 'event-message-block)))
+      (set! (-> gp-0 from) (process->ppointer self))
+      (set! (-> gp-0 num-params) 0)
+      (set! (-> gp-0 message) 'start)
+      (let ((s5-0 send-event-function)
+            (v1-2 (entity-by-name "cave-in-master-1"))
+            )
+        (s5-0
+          (if v1-2
+              (-> v1-2 extra process)
+              )
+          gp-0
+          )
+        )
+      )
+    (spydroid-setup)
+    (set! (-> self drill-speed target) 1.0)
+    (set! (-> self flying) #f)
+    (none)
+    )
+  :exit (behavior ()
+    (set! (-> self left-cover-angle target) 0.0)
+    (set! (-> self right-cover-angle target) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (widow-cleanup-launch-anim #f)
+    (if (zero? (spydroid-launch))
+        (go-virtual watch-droids-stage-1)
+        )
+    (widow-give-ammo)
+    (widow-common)
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  :post (the-as (function none :behavior widow) transform-post)
+  )
+
+(defstate hidden (widow)
+  :virtual #t
+  :enter (behavior ()
+    (ja-channel-set! 0)
+    (ja-post)
+    (set! (-> self movie-handle) (the-as handle #f))
+    (none)
+    )
+  :exit (behavior ()
+    (ja-channel-push! 1 0)
+    (ja :group! (-> self draw art-group data 8) :num! min)
+    (set! (-> self hud) (ppointer->handle (process-spawn hud-widow :init hud-init-by-other :to self)))
+    (let ((v1-13 (handle->process (-> self hud))))
+      (if v1-13
+          (set! (-> (the-as hud-widow v1-13) values 0 target) 1)
+          )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    (cond
+      ((and (= (-> self movie-handle) #f) (not (task-node-closed? (game-task-node tomb-boss-introduction))))
+       (when (and *target*
+                  (task-node-closed? (game-task-node tomb-boss-door))
+                  (not *scene-player*)
+                  (not *progress-process*)
+                  )
+         (let ((f0-0 (vector-vector-xz-distance (-> self circle-center) (-> *target* control trans))))
+           (cond
+             ((< f0-0 376832.0)
+              (set! (-> self movie-handle)
+                    (ppointer->handle (process-spawn scene-player :init scene-player-init "tomb-boss-intro" #t #f))
+                    )
+              )
+             ((< f0-0 409600.0)
+              (eval!
+                (new 'stack 'script-context (the-as basic (process->ppointer self)) self (the-as vector #f))
+                '(want-anim "tomb-boss-intro")
+                )
+              )
+             )
+           )
+         )
+       )
+      ((or (not (handle->process (-> self movie-handle)))
+           (task-node-closed? (game-task-node tomb-boss-introduction))
+           )
+       (set! (-> self heart) (ppointer->handle (process-spawn heart-mar (-> self root trans) :to self)))
+       (set-setting! 'music 'danger7 0 0)
+       (go-virtual launch-droids-stage-1)
+       )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior widow) sleep-code)
+  )
diff --git a/goal_src/jak2/levels/mars_tomb/widow2.gc b/goal_src/jak2/levels/mars_tomb/widow2.gc
index 3c979981ab..e147f3fbac 100644
--- a/goal_src/jak2/levels/mars_tomb/widow2.gc
+++ b/goal_src/jak2/levels/mars_tomb/widow2.gc
@@ -7,3 +7,393 @@
 
 ;; DECOMP BEGINS
 
+(defmethod deal-damage! widow-shot ((obj widow-shot) (arg0 process) (arg1 event-message-block))
+  "Constructs an [[attack-info]] according to the projectile's `options`"
+  (let ((t9-0 (method-of-type projectile deal-damage!)))
+    (when (t9-0 obj arg0 arg1)
+      (set! (-> obj hit-actor?) #t)
+      (if (= arg0 *target*)
+          (send-event (ppointer->process (-> obj parent)) 'shot-hit-target)
+          )
+      #t
+      )
+    )
+  )
+
+(defmethod widow-method-44 widow ((obj widow) (arg0 vector) (arg1 vector))
+  (let ((gp-0 (new 'stack-no-clear 'collide-query)))
+    (set! (-> gp-0 start-pos quad) (-> arg0 quad))
+    (vector-normalize-copy! (-> gp-0 move-dist) arg1 81920.0)
+    (let ((v1-1 gp-0))
+      (set! (-> v1-1 radius) 4096.0)
+      (set! (-> v1-1 collide-with) (collide-spec enemy hit-by-others-list))
+      (set! (-> v1-1 ignore-process0) obj)
+      (set! (-> v1-1 ignore-process1) #f)
+      (set! (-> v1-1 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+      (set! (-> v1-1 action-mask) (collide-action solid deadly))
+      )
+    (if (>= (fill-and-probe-using-line-sphere *collide-cache* gp-0) 0.0)
+        (return #f)
+        )
+    )
+  #t
+  )
+
+;; WARN: Return type mismatch sound-id vs none.
+(defmethod widow-method-45 widow ((obj widow) (arg0 vector) (arg1 vector) (arg2 vector))
+  (let ((s5-0 (new 'stack-no-clear 'projectile-init-by-other-params)))
+    (let ((f30-0 (/ 2013265900.0 (vector-length arg2)))
+          (s3-0 (new 'stack-no-clear 'vector))
+          )
+      (set! (-> s5-0 ent) (-> obj entity))
+      (set! (-> s5-0 charge) 1.0)
+      (set! (-> s5-0 options) (projectile-options account-for-target-velocity))
+      (set! (-> s5-0 pos quad) (-> arg1 quad))
+      (set! (-> s5-0 notify-handle) (process->handle obj))
+      (set! (-> s5-0 owner-handle) (the-as handle #f))
+      (set! (-> s5-0 ignore-handle) (process->handle obj))
+      (let* ((v1-13 *game-info*)
+             (a0-12 (+ (-> v1-13 attack-id) 1))
+             )
+        (set! (-> v1-13 attack-id) a0-12)
+        (set! (-> s5-0 attack-id) a0-12)
+        )
+      (set! (-> s5-0 timeout) (new 'static 'handle :process #x4b0 :u64 #x4b0))
+      (vector-normalize-copy! (-> s5-0 vel) arg2 491520.0)
+      (let ((f30-1 (fmin 16384.0 f30-0)))
+        (set-vector! s3-0 (-> arg2 z) (-> arg2 y) (- (-> arg2 x)) 1.0)
+        (vector-normalize! s3-0 (rand-vu-float-range (- f30-1) f30-1))
+        (vector+! (-> s5-0 vel) (-> s5-0 vel) s3-0)
+        (vector-cross! s3-0 s3-0 (-> s5-0 vel))
+        (vector-normalize! s3-0 (rand-vu-float-range (- f30-1) f30-1))
+        )
+      (vector+! (-> s5-0 vel) (-> s5-0 vel) s3-0)
+      )
+    (spawn-projectile widow-shot s5-0 obj *default-dead-pool*)
+    )
+  (if arg0
+      (sound-play "widow-fire")
+      )
+  (none)
+  )
+
+(defmethod widow-method-46 widow ((obj widow) (arg0 vector) (arg1 int))
+  (let ((s4-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data arg1)))
+        (s3-0 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> s3-0 quad) (-> obj node-list data arg1 bone transform vector 1 quad))
+    (if (widow-method-44 obj s4-0 s3-0)
+        (widow-method-45 obj arg0 s4-0 s3-0)
+        )
+    )
+  0
+  (none)
+  )
+
+(defmethod deactivate widow ((obj widow))
+  (if (nonzero? (-> obj drill-spark-part))
+      (kill-and-free-particles (-> obj drill-spark-part))
+      )
+  (if (nonzero? (-> obj drill-spark-part-alt))
+      (kill-and-free-particles (-> obj drill-spark-part-alt))
+      )
+  (if (nonzero? (-> obj extract-stone-part))
+      (kill-and-free-particles (-> obj extract-stone-part))
+      )
+  (if (nonzero? (-> obj insert-stone-part))
+      (kill-and-free-particles (-> obj insert-stone-part))
+      )
+  (if (nonzero? (-> obj land-part))
+      (kill-and-free-particles (-> obj land-part))
+      )
+  (if (nonzero? (-> obj green-charge-part))
+      (kill-and-free-particles (-> obj green-charge-part))
+      )
+  (if (nonzero? (-> obj green-fire-part))
+      (kill-and-free-particles (-> obj green-fire-part))
+      )
+  (if (-> obj drill-sound-playing)
+      (sound-stop (the-as sound-id (-> obj drill-sound)))
+      )
+  (if (-> obj drill-sweeten-sound-playing)
+      (sound-stop (the-as sound-id (-> obj drill-sweeten-sound)))
+      )
+  (if (-> obj hover-sound-playing)
+      (sound-stop (the-as sound-id (-> obj hover-sound)))
+      )
+  (if (-> obj shake-sound-playing)
+      (sound-stop (the-as sound-id (-> obj shake-sound)))
+      )
+  ((method-of-type process-drawable deactivate) obj)
+  (none)
+  )
+
+;; WARN: Return type mismatch process-drawable vs widow.
+(defmethod relocate widow ((obj widow) (arg0 int))
+  (if (nonzero? (-> obj left-cover-jm))
+      (&+! (-> obj left-cover-jm) arg0)
+      )
+  (if (nonzero? (-> obj right-cover-jm))
+      (&+! (-> obj right-cover-jm) arg0)
+      )
+  (if (nonzero? (-> obj left-drill-jm))
+      (&+! (-> obj left-drill-jm) arg0)
+      )
+  (if (nonzero? (-> obj right-drill-jm))
+      (&+! (-> obj right-drill-jm) arg0)
+      )
+  (if (nonzero? (-> obj drill-spark-part))
+      (&+! (-> obj drill-spark-part) arg0)
+      )
+  (if (nonzero? (-> obj drill-spark-part-alt))
+      (&+! (-> obj drill-spark-part-alt) arg0)
+      )
+  (if (nonzero? (-> obj extract-stone-part))
+      (&+! (-> obj extract-stone-part) arg0)
+      )
+  (if (nonzero? (-> obj insert-stone-part))
+      (&+! (-> obj insert-stone-part) arg0)
+      )
+  (if (nonzero? (-> obj land-part))
+      (&+! (-> obj land-part) arg0)
+      )
+  (if (nonzero? (-> obj green-charge-part))
+      (&+! (-> obj green-charge-part) arg0)
+      )
+  (if (nonzero? (-> obj green-fire-part))
+      (&+! (-> obj green-fire-part) arg0)
+      )
+  (dotimes (v1-44 5)
+    (if (nonzero? (-> obj lightning v1-44))
+        (&+! (-> obj lightning v1-44) arg0)
+        )
+    )
+  (the-as widow ((method-of-type process-drawable relocate) obj arg0))
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! widow ((obj widow) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (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
+            generic-attack
+            lunge
+            flop
+            punch
+            spin
+            roll
+            uppercut
+            bonk
+            tube
+            vehicle
+            flut-attack
+            board
+            mech-punch
+            dark-punch
+            dark-giant
+            )
+          )
+    (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 1) 0)))
+      (set! (-> s4-0 total-prims) (the-as uint 2))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec enemy))
+      (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 0.0 9216.0 36864.0)
+      (set! (-> s4-0 root-prim) s3-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 enemy))
+      (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 32768.0)
+      )
+    (set! (-> s4-0 nav-radius) 8192.0)
+    (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! (-> obj root) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-widow" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj skel generate-frame-function) create-interpolated2-joint-animation-frame)
+  (setup-masks (-> obj draw) 0 126)
+  (set! (-> obj root pause-adjust-distance) 245760.0)
+  (dotimes (v1-26 8)
+    (set! (-> obj catwalk v1-26) (the-as handle #f))
+    )
+  (let ((s4-2 (-> obj entity extra perm)))
+    (logior! (-> s4-2 status) (entity-perm-status bit-5))
+    0
+    (let ((s3-2 (new 'stack-no-clear 'vector)))
+      (set! (-> s3-2 quad) (-> arg0 extra trans quad))
+      (set! (-> s3-2 y) (+ -32768.0 (-> s3-2 y)))
+      (set! (-> s3-2 z) (+ 42475.52 (-> s3-2 z)))
+      (dotimes (s5-1 8)
+        (cond
+          ((not (logtest? (the-as int (-> s4-2 user-object 1)) (ash 1 s5-1)))
+           (set! (-> obj catwalk s5-1) (ppointer->handle (process-spawn tomb-boss-catwalk s3-2 s5-1 :to obj)))
+           (if (not (handle->process (-> obj catwalk s5-1)))
+               (format 0 "catwalk ~D failed to spawn~%" s5-1)
+               )
+           )
+          (else
+            (send-event (handle->process (-> obj catwalk 0)) 'catwalk-hit s5-1)
+            )
+          )
+        )
+      )
+    )
+  (dotimes (v1-62 8)
+    (set! (-> obj bomb v1-62) (the-as handle #f))
+    )
+  (dotimes (v1-65 2)
+    (set! (-> obj ammos v1-65) (the-as handle #f))
+    (set! (-> obj ammo-timers v1-65) 0)
+    )
+  (set! (-> obj attack-from-high-deg) #f)
+  (set! (-> obj which-gun) 0)
+  (set! (-> obj which-pod) 0)
+  (set! (-> obj bomb-hits) 0)
+  (set! (-> obj flying) #f)
+  (set! (-> obj previous-anim) 0)
+  (set! (-> obj circle-center quad) (-> obj root trans quad))
+  (set! (-> obj circle-center z) (+ 40960.0 (-> obj circle-center z)))
+  (init (-> obj theta) 0.0 0.01 91.022224 0.9)
+  (init (-> obj tilt) 0.0 0.01 91.022224 0.9)
+  (set! (-> obj left-cover-jm) (new 'process 'joint-mod (joint-mod-mode joint-set*) obj 90))
+  (set! (-> obj right-cover-jm) (new 'process 'joint-mod (joint-mod-mode joint-set*) obj 91))
+  (widow-float-seeker-method-9 (-> obj left-cover-angle) 0.0 0.01 0.1 0.9 0.25)
+  (widow-float-seeker-method-9 (-> obj right-cover-angle) 0.0 0.01 0.1 0.9 0.25)
+  (set! (-> obj left-drill-jm) (new 'process 'joint-mod (joint-mod-mode joint-set*) obj 11))
+  (set! (-> obj right-drill-jm) (new 'process 'joint-mod (joint-mod-mode joint-set*) obj 44))
+  (init (-> obj drill-speed) 0.0 0.01 0.1 0.9)
+  (let ((s5-2 (new 'stack-no-clear 'vector)))
+    (set! (-> s5-2 quad) (-> obj root trans quad))
+    (set! (-> obj baron) (process-spawn
+                           manipy
+                           :init manipy-init
+                           s5-2
+                           (-> obj entity)
+                           (art-group-get-by-name *level* "skel-baron" (the-as (pointer uint32) #f))
+                           #f
+                           0
+                           :to obj
+                           )
+          )
+    )
+  (logior! (-> obj baron 0 draw global-effect) (draw-control-global-effect disable-envmap))
+  (send-event (ppointer->process (-> obj baron)) 'anim-mode 'clone-anim)
+  (set! (-> obj baron 0 draw light-index) (mod (-> obj draw light-index) (the-as uint 10)))
+  (let ((v1-106 (-> obj baron)))
+    (if v1-106
+        (logclear! (-> v1-106 0 mask) (process-mask actor-pause))
+        )
+    )
+  (set! (-> obj pod) (ppointer->handle (process-spawn baron-pod (-> obj root trans) :to obj)))
+  (set! (-> obj heart) (the-as handle #f))
+  (set! (-> obj drill-spark-part) (create-launch-control (-> *part-group-id-table* 713) obj))
+  (set! (-> obj drill-spark-part-alt) (create-launch-control (-> *part-group-id-table* 714) obj))
+  (set! (-> obj extract-stone-time) 0)
+  (set! (-> obj extract-stone-part) (create-launch-control (-> *part-group-id-table* 715) obj))
+  (set! (-> obj insert-stone-time) 0)
+  (set! (-> obj insert-stone-part) (create-launch-control (-> *part-group-id-table* 716) obj))
+  (set! (-> obj land-part) (create-launch-control (-> *part-group-id-table* 730) obj))
+  (set! (-> obj green-charge-part) (create-launch-control (-> *part-group-id-table* 731) obj))
+  (set! (-> obj green-fire-part) (create-launch-control (-> *part-group-id-table* 732) obj))
+  (add-connection *part-engine* obj 73 obj 3251 (new 'static 'vector :w 819200.0))
+  (add-connection *part-engine* obj 77 obj 3251 (new 'static 'vector :w 819200.0))
+  (add-connection *part-engine* obj 78 obj 3251 (new 'static 'vector :w 819200.0))
+  (dotimes (s5-4 5)
+    (set! (-> obj lightning s5-4) (new
+                                    'process
+                                    'lightning-control
+                                    (new 'static 'lightning-spec
+                                      :name #f
+                                      :flags (lightning-spec-flags lsf0)
+                                      :start-color (new 'static 'rgba :r #x80 :g #x80 :b #x80 :a #x80)
+                                      :end-color (new 'static 'rgba :r #x80 :g #x80 :b #x80 :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 #x7 :page #x8c7)
+                                      :reduction 0.4
+                                      :num-points 48
+                                      :box-size 57344.0
+                                      :merge-factor 0.5
+                                      :merge-count 2
+                                      :radius 9216.0
+                                      :duration -1.0
+                                      :sound #f
+                                      )
+                                    obj
+                                    0.0
+                                    )
+          )
+    (let ((v1-148 (-> obj lightning s5-4))
+          (a0-97 0)
+          )
+      (let ((a1-48 (!= a0-97 (-> v1-148 state mode))))
+        (case a0-97
+          ((3)
+           (if a1-48
+               (set! (-> v1-148 state counter) 0.0)
+               )
+           )
+          ((1)
+           (set! (-> v1-148 state start-color) (-> v1-148 spec start-color))
+           (set! (-> v1-148 state end-color) (-> v1-148 spec end-color))
+           )
+          )
+        )
+      (set! (-> v1-148 state mode) (the-as lightning-mode a0-97))
+      )
+    )
+  (set! (-> obj catwalk-sound) (the-as uint (new-sound-id)))
+  (set! (-> obj drill-sound) (the-as uint (new-sound-id)))
+  (set! (-> obj drill-sound-playing) #f)
+  (set! (-> obj drill-sweeten-sound) (the-as uint (new-sound-id)))
+  (set! (-> obj drill-sweeten-sound-playing) #f)
+  (set! (-> obj hover-sound) (the-as uint (new-sound-id)))
+  (set! (-> obj hover-sound-playing) #f)
+  (set! (-> obj shake-sound) (the-as uint (new-sound-id)))
+  (set! (-> obj shake-sound-playing) #f)
+  (set! (-> obj hud) (the-as handle #f))
+  (set! (-> obj last-want-stone-talker) 0)
+  (set! (-> obj last-general-flying-talker) 0)
+  (set! (-> obj last-launch-droids-talker) 0)
+  (set! (-> obj last-launch-bombs-talker) 0)
+  (set! (-> obj last-shoot-gun-talker) 0)
+  (set! (-> obj last-stone-charge-up-talker) 0)
+  (set! (-> obj last-after-stone-shot-talker) 0)
+  (set! (-> obj last-leave-perch-talker) 0)
+  (set! (-> obj last-damaged-talker) 0)
+  (set! (-> obj kicked-bombs) 0)
+  (set! (-> obj launch-stages-completed) 0)
+  (set! (-> obj current-shoot-stage) 0)
+  (set! (-> obj last-gun-hit-stage) 0)
+  (set! (-> obj gun-hits) 0)
+  (set! (-> obj last-attack-id) (the-as uint 0))
+  (if (task-node-closed? (game-task-node tomb-boss-resolution))
+      (go (method-of-object obj beaten))
+      (go (method-of-object obj hidden))
+      )
+  (none)
+  )
diff --git a/goal_src/jak2/levels/nest/boss/nestb-scenes.gc b/goal_src/jak2/levels/nest/boss/nestb-scenes.gc
index 8ae7836eb3..7cbaa5fa3d 100644
--- a/goal_src/jak2/levels/nest/boss/nestb-scenes.gc
+++ b/goal_src/jak2/levels/nest/boss/nestb-scenes.gc
@@ -1772,8 +1772,8 @@ This commonly includes things such as:
   )
 
 (defun nestb-login ()
-  (set! *nav-network* (new 'loading-level 'nav-network))
-  (nav-network-method-9 *nav-network*)
+  ;; (set! *nav-network* (new 'loading-level 'nav-network))
+  ;; (nav-network-method-9 *nav-network*)
   0
   (none)
   )
@@ -1788,7 +1788,7 @@ This commonly includes things such as:
   )
 
 (defun nestb-activate ((arg0 level))
-  (nav-network-method-10 *nav-network* arg0 *nestb-adjacency*)
+  ;; (nav-network-method-10 *nav-network* arg0 *nestb-adjacency*)
   0
   (none)
   )
diff --git a/goal_src/jak2/levels/nest/flying-spider.gc b/goal_src/jak2/levels/nest/flying-spider.gc
index 1f45f19736..2b3cd3254a 100644
--- a/goal_src/jak2/levels/nest/flying-spider.gc
+++ b/goal_src/jak2/levels/nest/flying-spider.gc
@@ -5,5 +5,897 @@
 ;; name in dgo: flying-spider
 ;; dgos: NESTT, NES
 
+(declare-type flying-spider nav-enemy)
+
 ;; DECOMP BEGINS
 
+(deftype flying-spider-shot (metalhead-shot)
+  ()
+  :heap-base #x170
+  :method-count-assert 40
+  :size-assert         #x1f0
+  :flag-assert         #x28017001f0
+  )
+
+
+(defmethod play-impact-sound flying-spider-shot ((obj flying-spider-shot) (arg0 projectile-options))
+  (if (zero? arg0)
+      (sound-play "fly-spider-shot")
+      ((the-as (function projectile projectile-options sound-id) (find-parent-method flying-spider-shot 28))
+       obj
+       arg0
+       )
+      )
+  )
+
+(defun spawn-flying-spider-projectile ((arg0 flying-spider) (arg1 vector) (arg2 vector) (arg3 float))
+  (let ((gp-0 (new 'stack-no-clear 'projectile-init-by-other-params)))
+    (let ((v1-1 (vector-! (new 'stack-no-clear 'vector) arg2 arg1)))
+      (set! (-> gp-0 ent) (-> arg0 entity))
+      (set! (-> gp-0 charge) 1.0)
+      (set! (-> gp-0 options) (projectile-options))
+      (set! (-> gp-0 notify-handle) (process->handle arg0))
+      (set! (-> gp-0 owner-handle) (the-as handle #f))
+      (set! (-> gp-0 ignore-handle) (process->handle arg0))
+      (let* ((a0-10 *game-info*)
+             (a2-11 (+ (-> a0-10 attack-id) 1))
+             )
+        (set! (-> a0-10 attack-id) a2-11)
+        (set! (-> gp-0 attack-id) a2-11)
+        )
+      (set! (-> gp-0 timeout) (new 'static 'handle :process #x4b0 :u64 #x4b0))
+      (set! (-> gp-0 pos quad) (-> arg1 quad))
+      (vector-normalize-copy! (-> gp-0 vel) v1-1 arg3)
+      )
+    (spawn-projectile flying-spider-shot gp-0 arg0 *default-dead-pool*)
+    )
+  )
+
+(deftype flying-spider (nav-enemy)
+  ((my-up-vector vector     :inline :offset-assert 608)
+   (gspot-normal vector     :inline :offset-assert 624)
+   (gspot-timer  time-frame         :offset-assert 640)
+   (focus-dir    uint16             :offset-assert 648)
+   (path-u       float              :offset-assert 652)
+   (path-du      float              :offset-assert 656)
+   )
+  :heap-base #x220
+  :method-count-assert 183
+  :size-assert         #x294
+  :flag-assert         #xb702200294
+  (:methods
+    (ambush-falling () _type_ :state 178)
+    (attack () _type_ :state 179)
+    (attack-fire () _type_ :state 180)
+    (turn-to-focus () _type_ :state 181)
+    (flying-spider-method-182 (_type_ vector) none 182)
+    )
+  )
+
+
+(defskelgroup skel-flying-spider flying-spider flying-spider-lod0-jg flying-spider-walk0-ja
+              ((flying-spider-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 1.5 0 6)
+              :shadow flying-spider-shadow-mg
+              )
+
+(define *flying-spider-nav-enemy-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #f
+    :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 idle-control-frame 4
+      (new 'static 'idle-control-frame :command (ic-cmd push) :param0 #x1e)
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x5 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 5
+    :notice-anim 5
+    :hostile-anim 9
+    :hit-anim 5
+    :knocked-anim 12
+    :knocked-land-anim 13
+    :die-anim 18
+    :die-falling-anim 18
+    :victory-anim 10
+    :jump-wind-up-anim -1
+    :jump-in-air-anim -1
+    :jump-land-anim -1
+    :neck-joint 25
+    :look-at-joint 27
+    :bullseye-joint 27
+    :sound-hit (static-sound-name "fly-spider-hit")
+    :sound-die (static-sound-name "fly-spider-die")
+    :notice-distance (meters 50)
+    :notice-distance-delta (meters 10)
+    :proximity-notice-distance (meters 12.5)
+    :default-hit-points 16
+    :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
+    :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher)
+    :jump-height-min (meters 3)
+    :jump-height-factor 0.5
+    :shadow-size (meters 1)
+    :shadow-max-y (meters 1)
+    :shadow-min-y (meters -1)
+    :shadow-locus-dist (meters 150)
+    :gem-joint 27
+    :gem-seg #x2
+    :gem-no-seg #x4
+    :gem-offset (new 'static 'sphere :y 2048.0 :z 3112.96 :r 327680.0)
+    :callback-info #f
+    :use-momentum #f
+    :use-frustration #f
+    :use-stop-chase #f
+    :use-circling #f
+    :use-pacing #f
+    :walk-anim 9
+    :turn-anim 5
+    :run-anim 9
+    :taunt-anim -1
+    :run-travel-speed (meters 6)
+    :run-acceleration (meters 1)
+    :run-turning-acceleration (meters 10)
+    :walk-travel-speed (meters 3)
+    :walk-acceleration (meters 1)
+    :walk-turning-acceleration (meters 5)
+    :maximum-rotation-rate (degrees 112.5)
+    :notice-nav-radius (meters 20)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 20480.0
+    :circle-dist-hi 61440.0
+    :nav-mesh #f
+    )
+  )
+
+(set! (-> *flying-spider-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+(defstate active (flying-spider)
+  :virtual #t
+  :code (behavior ()
+    (until #f
+      (ja-no-eval :group! flying-spider-idle0-ja
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim flying-spider-idle0-ja) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior flying-spider) nav-enemy-simple-post)
+  )
+
+(defstate ambush (flying-spider)
+  :virtual #t
+  :enter (behavior ()
+    (when (logtest? (-> self enemy-flags) (enemy-flag auto-reset-penetrate))
+      (logclear! (-> self enemy-flags) (enemy-flag auto-reset-penetrate))
+      (let ((gp-0 (-> self on-notice)))
+        (if gp-0
+            (eval!
+              (new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans))
+              (the-as pair gp-0)
+              )
+            )
+        )
+      )
+    (logclear! (-> self enemy-flags) (enemy-flag lock-focus death-start))
+    (set! (-> self path-du) (get-rand-float-range self 0.2 0.5))
+    (set-vector! (-> self root-override2 scale) 0.0 0.0 0.0 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (if (= (-> self path-u) 1.0)
+        (go-virtual ambush-falling)
+        )
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 0)
+    (until #f
+      (ja-no-eval :group! flying-spider-idle-flying-ja
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim flying-spider-idle-flying-ja) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (get-point-at-percent-along-path! (-> self path) (-> self root-override2 trans) (-> self path-u) 'interp)
+    (set! (-> self path-u) (seek-ease
+                             (-> self path-u)
+                             1.0
+                             (* (-> self path-du) (-> self clock seconds-per-frame))
+                             0.2
+                             (* 0.04 (-> self clock seconds-per-frame))
+                             )
+          )
+    (let ((f0-7 (-> self path-u)))
+      (set-vector! (-> self root-override2 scale) f0-7 f0-7 f0-7 0.0)
+      )
+    (let ((a1-3 (displacement-between-points-at-percent-normalized!
+                  (-> self path)
+                  (new 'stack-no-clear 'vector)
+                  (fmin 1.0 (+ 0.2 (-> self path-u)))
+                  )
+                )
+          )
+      (forward-up-nopitch->quaternion (-> self root-override2 quat) a1-3 *y-vector*)
+      )
+    (nav-enemy-simple-post)
+    (none)
+    )
+  )
+
+(defstate ambush-falling (flying-spider)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior flying-spider) enemy-event-handler)
+  :code (behavior ()
+    (ja-no-eval :group! flying-spider-drop-down-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim flying-spider-drop-down-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (until (logtest? (-> self root-override2 status) (collide-status on-ground))
+      (suspend)
+      )
+    (let ((s5-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat)))
+          (gp-0 (new 'stack-no-clear 'quaternion))
+          )
+      (set! (-> s5-0 y) 0.0)
+      (vector-xz-normalize! s5-0 1.0)
+      (forward-up-nopitch->quaternion gp-0 s5-0 *y-vector*)
+      (ja-no-eval :group! flying-spider-drop-down-land-ja
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim flying-spider-drop-down-land-ja) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (quaternion-slerp!
+          (-> self root-override2 quat)
+          (-> self root-override2 quat)
+          gp-0
+          (* 2.0 (-> self clock seconds-per-frame))
+          )
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    (enemy-method-127 self 40960.0 40960.0 #t (collide-spec backgnd))
+    (go-hostile self)
+    (none)
+    )
+  :post (behavior ()
+    (let ((a1-0 (new 'stack-no-clear 'collide-query)))
+      (enemy-method-125 self a1-0 (-> self root-override2 root-prim prim-core collide-with) 8192.0 81920.0 1024.0)
+      )
+    (flying-spider-method-182
+      self
+      (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat))
+      )
+    (nav-enemy-falling-post)
+    (none)
+    )
+  )
+
+(defstate hostile (flying-spider)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior flying-spider) enemy-event-handler)
+  :trans (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy hostile) trans)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (let ((a0-1 (handle->process (-> self focus handle))))
+      (when (and a0-1
+                 (< (vector-vector-distance (get-trans (the-as process-focusable a0-1) 0) (-> self root-override2 trans))
+                    81920.0
+                    )
+                 )
+        (if (not (enemy-method-96 self 5461.3335 #t))
+            (go-virtual turn-to-focus)
+            (go-virtual attack)
+            )
+        )
+      )
+    (none)
+    )
+  )
+
+(defstate turn-to-focus (flying-spider)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior flying-spider) enemy-event-handler)
+  :enter (behavior ()
+    (let ((v1-0 self))
+      (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-0 enemy-flags))))
+      )
+    0
+    (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
+    (none)
+    )
+  :trans (behavior ()
+    (if (>= 2 (the-as int (-> self focus aware)))
+        (go-stare self)
+        )
+    (let ((s3-0 (handle->process (-> self focus handle))))
+      (cond
+        (s3-0
+          (let ((gp-0 (vector-x-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat)))
+                (s4-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat)))
+                (s5-1 (vector-!
+                        (new 'stack-no-clear 'vector)
+                        (get-trans (the-as process-focusable s3-0) 0)
+                        (-> self root-override2 trans)
+                        )
+                      )
+                )
+            (set! (-> gp-0 y) 0.0)
+            (set! (-> s4-0 y) 0.0)
+            (set! (-> s5-1 y) 0.0)
+            (vector-normalize! gp-0 1.0)
+            (vector-normalize! s4-0 1.0)
+            (vector-normalize! s5-1 1.0)
+            (cond
+              ((< (cos 910.2222) (vector-dot s5-1 s4-0))
+               (set! (-> self focus-dir) (the-as uint 0))
+               0
+               )
+              ((< 0.0 (vector-dot s5-1 gp-0))
+               (set! (-> self focus-dir) (the-as uint 1))
+               )
+              (else
+                (set! (-> self focus-dir) (the-as uint 2))
+                )
+              )
+            )
+          )
+        (else
+          (go-stare self)
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (when (= (-> self focus-dir) 1)
+        (let ((v1-4 (ja-group)))
+          (if (not (and v1-4 (= v1-4 flying-spider-turn-left-180-ja)))
+              (ja-channel-push! 1 (seconds 0.15))
+              )
+          )
+        (ja-no-eval :group! flying-spider-turn-left-180-ja :num! (loop!) :frame-num 0.0)
+        (while (= (-> self focus-dir) 1)
+          (suspend)
+          (ja :num! (loop!))
+          )
+        )
+      (when (= (-> self focus-dir) 2)
+        (let ((v1-28 (ja-group)))
+          (if (not (and v1-28 (= v1-28 flying-spider-turn-right-180-ja)))
+              (ja-channel-push! 1 (seconds 0.15))
+              )
+          )
+        (ja-no-eval :group! flying-spider-turn-right-180-ja :num! (loop!) :frame-num 0.0)
+        (while (= (-> self focus-dir) 2)
+          (suspend)
+          (ja :num! (loop!))
+          )
+        )
+      (if (zero? (-> self focus-dir))
+          (go-hostile self)
+          )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (flying-spider-method-182
+      self
+      (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat))
+      )
+    (nav-enemy-face-focus-post)
+    (none)
+    )
+  )
+
+(defstate stare (flying-spider)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy stare) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (let ((v1-4 self))
+      (set! (-> v1-4 enemy-flags) (the-as enemy-flag (logclear (-> v1-4 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (none)
+    )
+  )
+
+(defstate attack (flying-spider)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior flying-spider) enemy-event-handler)
+  :enter (behavior ()
+    (let ((v1-0 self))
+      (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logclear (-> v1-0 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (none)
+    )
+  :trans (behavior ()
+    (let ((a0-1 (enemy-method-107 self)))
+      (cond
+        ((or (not a0-1) (>= 2 (the-as int (-> self focus aware))))
+         (go-stare self)
+         )
+        ((< 98304.0 (vector-vector-distance (get-trans a0-1 0) (-> self root-override2 trans)))
+         (go-hostile self)
+         )
+        ((not (enemy-method-96 self 5461.3335 #t))
+         (go-virtual turn-to-focus)
+         )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (ja-channel-push! 1 (seconds 0.15))
+      (ja-no-eval :group! flying-spider-idle0-ja
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim flying-spider-idle0-ja) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      (if (enemy-method-107 self)
+          (go-virtual attack-fire)
+          )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-simple-post)
+    (none)
+    )
+  )
+
+(defstate attack-fire (flying-spider)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('event-attack-l)
+       (let* ((s5-0 (-> self node-list data 30))
+              (gp-0 (vector<-cspace! (new 'stack-no-clear 'vector) s5-0))
+              (a0-3 (vector-normalize-copy! (new 'stack-no-clear 'vector) (-> s5-0 bone transform vector 2) 163840.0))
+              (a2-3 (vector+! (new 'stack-no-clear 'vector) gp-0 a0-3))
+              )
+         (spawn-flying-spider-projectile self gp-0 a2-3 532480.0)
+         )
+       )
+      (('event-attack-r)
+       (let* ((s5-1 (-> self node-list data 35))
+              (gp-1 (vector<-cspace! (new 'stack-no-clear 'vector) s5-1))
+              (a0-7 (vector-normalize-copy! (new 'stack-no-clear 'vector) (-> s5-1 bone transform vector 2) -163840.0))
+              (a2-6 (vector+! (new 'stack-no-clear 'vector) gp-1 a0-7))
+              )
+         (spawn-flying-spider-projectile self gp-1 a2-6 532480.0)
+         )
+       )
+      (else
+        (enemy-event-handler proc arg1 event-type event)
+        )
+      )
+    )
+  :enter (behavior ()
+    (let ((v1-0 self))
+      (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logclear (-> v1-0 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.1))
+    (ja-no-eval :group! flying-spider-shoot-start-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim flying-spider-shoot-start-ja) frames num-frames) -1)) 2.0)
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! max 2.0))
+      )
+    (ja-no-eval :group! flying-spider-shoot-right-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim flying-spider-shoot-right-ja) frames num-frames) -1)) 2.0)
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! max 2.0))
+      )
+    (ja-no-eval :group! flying-spider-shoot-left-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim flying-spider-shoot-left-ja) frames num-frames) -1)) 2.0)
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! max 2.0))
+      )
+    (ja-no-eval :group! flying-spider-shoot-stop-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim flying-spider-shoot-stop-ja) frames num-frames) -1)) 2.0)
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! max 2.0))
+      )
+    (go-virtual attack)
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-simple-post)
+    (none)
+    )
+  )
+
+(defstate die (flying-spider)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior flying-spider) enemy-event-handler)
+  :enter (behavior ()
+    (enemy-method-132 self)
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self hit-points) 0)
+    (enemy-method-103 self)
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.075))
+    (let ((f30-0 (get-rand-float-range self 0.8 1.2)))
+      (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override die-anim))
+                  :num! (seek!
+                    (the float
+                         (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override die-anim)))
+                                frames
+                                num-frames
+                                )
+                            -1
+                            )
+                         )
+                    f30-0
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      )
+    (send-event self 'death-end)
+    (let ((v1-34 (-> self root-override2 root-prim)))
+      (set! (-> v1-34 prim-core collide-as) (collide-spec))
+      (set! (-> v1-34 prim-core collide-with) (collide-spec))
+      )
+    0
+    (while (-> self child)
+      (suspend)
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  :post (the-as (function none :behavior flying-spider) enemy-simple-post)
+  )
+
+(defmethod enemy-method-74 flying-spider ((obj flying-spider) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (case arg2
+    (('hit 'hit-knocked)
+     (logclear! (-> obj mask) (process-mask actor-pause))
+     (logclear! (-> obj focus-status) (focus-status dangerous))
+     (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice))
+     (logior! (-> obj enemy-flags) (enemy-flag chase-startup))
+     (logior! (-> obj focus-status) (focus-status hit))
+     (if (zero? (-> obj hit-points))
+         (logior! (-> obj focus-status) (focus-status dead))
+         )
+     (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup))
+     (enemy-method-62 obj)
+     (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
+     (process-contact-action arg0)
+     (send-event arg0 'get-attack-count 1)
+     (cond
+       ((zero? (-> obj hit-points))
+        (let ((s5-1 (-> obj incoming knocked-type)))
+          (cond
+            ((and (= s5-1 (knocked-type knocked-type-4))
+                  (not (and (-> obj next-state) (let ((v1-32 (-> obj next-state name)))
+                                                  (or (= v1-32 'knocked) (= v1-32 'jump) (= v1-32 'jump-land))
+                                                  )
+                            )
+                       )
+                  (zero? (get-rand-int obj 3))
+                  (let ((f0-0 (vector-vector-distance-squared (-> obj root-override2 trans) (target-pos 0)))
+                        (f1-0 32768.0)
+                        )
+                    (>= f0-0 (* f1-0 f1-0))
+                    )
+                  )
+             (enemy-method-73 obj)
+             )
+            ((or (= s5-1 (knocked-type knocked-type-4)) (= s5-1 (knocked-type knocked-type-6)))
+             (set! (-> obj incoming knocked-type) (knocked-type knocked-type-0))
+             (go (method-of-object obj knocked))
+             )
+            (else
+              (go (method-of-object obj knocked))
+              )
+            )
+          )
+        )
+       (else
+         (go (method-of-object obj knocked))
+         )
+       )
+     #t
+     )
+    (('death-start)
+     (let ((v1-52 (-> obj root-override2 root-prim)))
+       (set! (-> v1-52 prim-core collide-as) (collide-spec))
+       (set! (-> v1-52 prim-core collide-with) (collide-spec))
+       )
+     0
+     ((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 enemy-method-55 flying-spider ((obj flying-spider))
+  ((method-of-type nav-enemy enemy-method-55) obj)
+  (none)
+  )
+
+;; WARN: Return type mismatch symbol vs pat-surface.
+(defmethod enemy-method-125 flying-spider ((obj flying-spider) (arg0 collide-query) (arg1 collide-spec) (arg2 float) (arg3 float) (arg4 float))
+  (with-pp
+    (the-as
+      pat-surface
+      (when (find-ground (-> obj root-override2) arg0 arg1 arg2 arg3 arg4)
+        (set! (-> obj root-override2 ground-pat) (-> arg0 best-other-tri pat))
+        (when (>= (- (-> pp clock frame-counter) (-> obj gspot-timer)) (seconds 0.2))
+          (let ((a1-2 (new 'stack-no-clear 'collide-query)))
+            (set! (-> a1-2 start-pos quad) (-> obj root-override2 gspot-pos quad))
+            (set! (-> a1-2 start-pos y) (+ 2048.0 (-> a1-2 start-pos y)))
+            (set-vector! (-> a1-2 move-dist) 0.0 -6144.0 0.0 0.0)
+            (let ((v1-10 a1-2))
+              (set! (-> v1-10 radius) 4915.2)
+              (set! (-> v1-10 collide-with) arg1)
+              (set! (-> v1-10 ignore-process0) obj)
+              (set! (-> v1-10 ignore-process1) #f)
+              (set! (-> v1-10 ignore-pat) (-> obj root-override2 pat-ignore-mask))
+              (set! (-> v1-10 action-mask) (collide-action solid))
+              )
+            (fill-using-line-sphere *collide-cache* a1-2)
+            )
+          (let ((s5-1 (new 'stack-no-clear 'vector)))
+            (vector-reset! s5-1)
+            (dotimes (s4-1 (-> *collide-cache* num-tris))
+              (let* ((v1-16 (-> *collide-cache* tris s4-1))
+                     (s2-1 (vector-! (new 'stack-no-clear 'vector) (-> v1-16 vertex 1) (the-as vector (-> v1-16 vertex))))
+                     (s1-1 (vector-! (new 'stack-no-clear 'vector) (-> v1-16 vertex 2) (the-as vector (-> v1-16 vertex))))
+                     (s3-0 (new 'stack-no-clear 'vector))
+                     )
+                (vector-normalize! s2-1 1.0)
+                (vector-normalize! s1-1 1.0)
+                (vector-cross! s3-0 s2-1 s1-1)
+                (if (< (cos 10922.667) (vector-dot s3-0 *y-vector*))
+                    (vector+! s5-1 s5-1 s3-0)
+                    )
+                )
+              )
+            (vector-normalize-copy! (-> obj gspot-normal) s5-1 1.0)
+            )
+          (set! (-> obj gspot-timer) (-> pp clock frame-counter))
+          )
+        #t
+        )
+      )
+    )
+  )
+
+(defmethod flying-spider-method-182 flying-spider ((obj flying-spider) (arg0 vector))
+  (with-pp
+    (cond
+      ((= (-> obj root-override2 gspot-pos y) -40959590.0)
+       (set! (-> arg0 y) 0.0)
+       (vector-normalize! arg0 1.0)
+       (quaternion-set! (-> obj root-override2 quat) 0.0 (-> arg0 x) 0.0 (+ 1.0 (-> arg0 z)))
+       (quaternion-normalize! (-> obj root-override2 quat))
+       )
+      (else
+        (let ((s4-0 (new 'stack-no-clear 'vector)))
+          (set! (-> s4-0 quad) (-> *up-vector* quad))
+          (let ((s3-0 (new 'stack-no-clear 'quaternion)))
+            (quaternion-from-two-vectors-max-angle! s3-0 s4-0 (-> obj gspot-normal) 4551.1113)
+            (vector-orient-by-quat! s4-0 s4-0 s3-0)
+            )
+          (let ((s3-1 (-> obj my-up-vector)))
+            (new 'stack-no-clear 'vector)
+            (vector-deg-seek s3-1 s3-1 s4-0 (* 910.2222 (-> pp clock seconds-per-frame)))
+            (vector-normalize! s3-1 1.0)
+            (set! (-> arg0 y) 0.0)
+            (vector-normalize! arg0 1.0)
+            (forward-up->quaternion (-> obj root-override2 quat) arg0 s3-1)
+            )
+          )
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+(defmethod nav-enemy-method-142 flying-spider ((obj flying-spider) (arg0 nav-control))
+  (let ((t9-0 (method-of-object obj flying-spider-method-182))
+        (a2-0 (-> arg0 state))
+        (a1-1 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> a1-1 quad) (-> a2-0 heading quad))
+    (t9-0 obj a1-1)
+    )
+  0
+  (none)
+  )
+
+(defmethod enemy-method-109 flying-spider ((obj flying-spider) (arg0 int))
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch int vs penetrate.
+(defmethod enemy-method-59 flying-spider ((obj flying-spider))
+  (the-as penetrate 0)
+  )
+
+(defmethod enemy-method-51 flying-spider ((obj flying-spider))
+  (quaternion-y-angle (-> obj root-override2 quat))
+  )
+
+(defmethod coin-flip? flying-spider ((obj flying-spider))
+  "@returns The result of a 50/50 RNG roll"
+  #f
+  )
+
+;; WARN: Return type mismatch collide-shape-moving vs none.
+(defmethod enemy-method-114 flying-spider ((obj flying-spider))
+  "@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))
+    (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 enemy pusher))
+      (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 can-ride deadly no-standon))
+      (set! (-> s4-0 transform-index) 3)
+      (set-vector! (-> s4-0 local-sphere) 0.0 3072.0 0.0 16384.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (pusher-init s5-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 pusher))
+      (set! (-> v1-15 prim-core collide-with)
+            (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list)
+            )
+      (set! (-> v1-15 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set-vector! (-> v1-15 local-sphere) 0.0 7372.8 0.0 7372.8)
+      )
+    (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 pusher))
+      (set! (-> v1-17 prim-core action) (collide-action solid can-ride no-standon))
+      (set! (-> v1-17 transform-index) 24)
+      (set-vector! (-> v1-17 local-sphere) 0.0 4096.0 -819.2 7372.8)
+      )
+    (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 pusher))
+      (set! (-> v1-19 prim-core action) (collide-action solid can-ride no-standon))
+      (set! (-> v1-19 transform-index) 27)
+      (set-vector! (-> v1-19 local-sphere) 0.0 -819.2 819.2 4096.0)
+      )
+    (let ((v1-21 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-21 prim-core collide-as) (collide-spec enemy pusher))
+      (set! (-> v1-21 prim-core action) (collide-action solid can-ride no-standon))
+      (set! (-> v1-21 transform-index) 3)
+      (set-vector! (-> v1-21 local-sphere) 6144.0 -2457.6 -3276.8 5734.4)
+      )
+    (let ((v1-23 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-23 prim-core collide-as) (collide-spec enemy pusher))
+      (set! (-> v1-23 prim-core action) (collide-action solid can-ride no-standon))
+      (set! (-> v1-23 transform-index) 3)
+      (set-vector! (-> v1-23 local-sphere) -6144.0 -2457.6 -3276.8 5734.4)
+      )
+    (set! (-> s5-0 nav-radius) 12288.0)
+    (let ((v1-25 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-25 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-25 prim-core collide-with))
+      )
+    (set! (-> obj root-override2) s5-0)
+    )
+  (none)
+  )
+
+(defmethod enemy-method-115 flying-spider ((obj flying-spider))
+  "@abstract"
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-flying-spider" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (enemy-method-113 obj *flying-spider-nav-enemy-info*)
+  (let ((v1-5 (-> obj neck)))
+    (set! (-> v1-5 up) (the-as uint 1))
+    (set! (-> v1-5 nose) (the-as uint 2))
+    (set! (-> v1-5 ear) (the-as uint 0))
+    (set-vector! (-> v1-5 twist-max) 11832.889 11832.889 0.0 1.0)
+    (set! (-> v1-5 ignore-angle) 30947.555)
+    )
+  (set! (-> obj root-override2 dynam gravity y) 327680.0)
+  (set! (-> obj root-override2 dynam gravity-length) 327680.0)
+  (set! (-> obj root-override2 dynam gravity-max) 327680.0)
+  (set! (-> obj path) (new 'process 'curve-control obj 'path -1000000000.0))
+  (set! (-> obj path-u) 0.0)
+  (logior! (-> obj path flags) (path-control-flag display draw-line draw-point draw-text))
+  (add-connection *part-engine* obj 27 obj 318 (new 'static 'vector :x 1392.64 :y 204.8 :z 2621.44 :w 163840.0))
+  (add-connection
+    *part-engine*
+    obj
+    27
+    obj
+    318
+    (new 'static 'vector :x -1392.64 :y 204.8 :z 2621.44 :w 163840.0)
+    )
+  (set! (-> obj my-up-vector quad) (-> *y-vector* quad))
+  (set! (-> obj gspot-normal quad) (-> *y-vector* quad))
+  (set! (-> obj gspot-timer) 0)
+  0
+  (none)
+  )
diff --git a/goal_src/jak2/levels/nest/mammoth.gc b/goal_src/jak2/levels/nest/mammoth.gc
index c7004996d8..285a583abd 100644
--- a/goal_src/jak2/levels/nest/mammoth.gc
+++ b/goal_src/jak2/levels/nest/mammoth.gc
@@ -7,3 +7,1775 @@
 
 ;; DECOMP BEGINS
 
+(deftype mammoth (nav-enemy)
+  ((joint-ik               joint-mod-ik 4         :offset-assert 604)
+   (ik-handle-pos          vector       4 :inline :offset-assert 624)
+   (ik-handle-y            float        4         :offset-assert 688)
+   (heel-lerp              float        4         :offset-assert 704)
+   (foot-flags             uint16                 :offset-assert 720)
+   (old-foot-flags         uint16                 :offset-assert 722)
+   (y-level                float                  :offset-assert 724)
+   (foot-pos               vector       4 :inline :offset-assert 736)
+   (my-up-vector           vector       :inline   :offset-assert 800)
+   (my-up-quat             quaternion   :inline   :offset-assert 816)
+   (move-pos               vector       2 :inline :offset-assert 832)
+   (travel-dest            vector       :inline   :offset-assert 864)
+   (tilt-quat              quaternion   :inline   :offset-assert 880)
+   (path-index             int32                  :offset-assert 896)
+   (path-index-dir         int32                  :offset-assert 900)
+   (path-pos               float                  :offset-assert 904)
+   (turn-angle             float                  :offset-assert 908)
+   (gspot-timer            time-frame             :offset-assert 912)
+   (gspot-normal           vector       :inline   :offset-assert 928)
+   (attack-timer           time-frame             :offset-assert 944)
+   (lightning-timer        time-frame             :offset-assert 952)
+   (lightning-attack-timer time-frame             :offset-assert 960)
+   (spawn-timer            time-frame             :offset-assert 968)
+   (turn-anim-start        int32                  :offset-assert 976)
+   (turn-anim              int32                  :offset-assert 980)
+   (turn-anim-end          int32                  :offset-assert 984)
+   (turn-move-start        float                  :offset-assert 988)
+   (turn-move-end          float                  :offset-assert 992)
+   (feet-ik-init-timer     time-frame             :offset-assert 1000)
+   )
+  :heap-base #x370
+  :method-count-assert 186
+  :size-assert         #x3f0
+  :flag-assert         #xba037003f0
+  (:methods
+    (waiting () _type_ :state 178)
+    (wait-to-walk () _type_ :state 179)
+    (walking () _type_ :state 180)
+    (walking-attack () _type_ :state 181)
+    (turning () _type_ :state 182)
+    (mammoth-method-183 (_type_) none 183)
+    (mammoth-method-184 (_type_) none 184)
+    (mammoth-method-185 (_type_ vector int) none 185)
+    )
+  )
+
+
+(defskelgroup skel-mammoth mammoth mammoth-lod0-jg mammoth-walk0-ja
+              ((mammoth-lod0-mg (meters 20)) (mammoth-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0 4.5 0 17)
+              :shadow mammoth-shadow-mg
+              )
+
+(define *mammoth-nav-enemy-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #f
+    :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 idle-control-frame 4
+      (new 'static 'idle-control-frame :command (ic-cmd push) :param0 #x1e)
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x6 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 6
+    :notice-anim 6
+    :hostile-anim 6
+    :hit-anim 6
+    :knocked-anim 6
+    :knocked-land-anim 6
+    :die-anim -1
+    :die-falling-anim -1
+    :victory-anim 6
+    :jump-wind-up-anim -1
+    :jump-in-air-anim -1
+    :jump-land-anim -1
+    :neck-joint 6
+    :look-at-joint 7
+    :bullseye-joint 7
+    :notice-distance (meters 30)
+    :notice-distance-delta (meters 10)
+    :default-hit-points 80
+    :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
+    :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 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)
+    :callback-info #f
+    :use-momentum #f
+    :use-frustration #f
+    :use-stop-chase #f
+    :use-circling #f
+    :use-pacing #f
+    :walk-anim 6
+    :turn-anim 6
+    :run-anim 7
+    :taunt-anim 6
+    :run-travel-speed (meters 6)
+    :run-acceleration (meters 1)
+    :run-turning-acceleration (meters 20)
+    :walk-travel-speed (meters 4.5)
+    :walk-acceleration (meters 10)
+    :walk-turning-acceleration (meters 1)
+    :maximum-rotation-rate (degrees 31.249998)
+    :notice-nav-radius (meters 1)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 20480.0
+    :circle-dist-hi 61440.0
+    :nav-mesh #f
+    )
+  )
+
+(set! (-> *mammoth-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+(define *mammoth-lightning-joint-tbl* (new 'static 'boxed-array :type int32 50 51 52 53 54 55))
+
+(deftype mammoth-ik-setup (structure)
+  ((elbow-index int32   :offset-assert   0)
+   (hand-dist   float   :offset-assert   4)
+   (ground-dist float   :offset-assert   8)
+   (foot-flag   uint16  :offset-assert  12)
+   )
+  :method-count-assert 9
+  :size-assert         #xe
+  :flag-assert         #x90000000e
+  )
+
+
+(define *mammoth-ik-setup*
+  (new 'static 'inline-array mammoth-ik-setup 4
+    (new 'static 'mammoth-ik-setup :elbow-index 9 :hand-dist 5640.192 :ground-dist 6789.12 :foot-flag #x1)
+    (new 'static 'mammoth-ik-setup :elbow-index 12 :hand-dist -5640.192 :ground-dist 6789.12 :foot-flag #x2)
+    (new 'static 'mammoth-ik-setup :elbow-index 24 :hand-dist 6574.08 :ground-dist 3913.728 :foot-flag #x8)
+    (new 'static 'mammoth-ik-setup :elbow-index 27 :hand-dist -6574.08 :ground-dist 3913.728 :foot-flag #x4)
+    )
+  )
+
+(defbehavior mammoth-walk-post mammoth ()
+  (compute-alignment! (-> self align))
+  (align-vel-and-quat-only!
+    (-> self align)
+    (align-opts adjust-xz-vel)
+    (vector-normalize! (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat)) 65536.0)
+    #x3f800000
+    1.0
+    1.0
+    )
+  (+! (-> self root-override2 transv y)
+      (* (-> self enemy-info-override movement-gravity) (-> self clock seconds-per-frame))
+      )
+  (let ((a2-1 (new 'stack-no-clear 'move-above-ground-params)))
+    (let ((v1-9 (-> self enemy-info-override)))
+      (set! (-> a2-1 gnd-collide-with) (the-as collide-spec (-> self gnd-collide)))
+      (set! (-> a2-1 popup) 8192.0)
+      (set! (-> a2-1 dont-move-if-overlaps?) #f)
+      (set! (-> a2-1 hover-if-no-ground?) #f)
+      (set! (-> a2-1 overlaps-params options) (overlaps-others-options oo0 oo2))
+      (set! (-> a2-1 overlaps-params collide-with-filter) (-> v1-9 overlaps-others-collide-with-filter))
+      )
+    (set! (-> a2-1 overlaps-params tlist) *touching-list*)
+    (-> a2-1 overlaps-params)
+    (enemy-method-128 self (-> self root-override2 transv) a2-1)
+    )
+  (do-push-aways (-> self root-override2))
+  (let ((s5-1
+          (vector-normalize!
+            (vector-! (new 'stack-no-clear 'vector) (-> self travel-dest) (-> self root-override2 trans))
+            1.0
+            )
+          )
+        (gp-1 (new 'stack-no-clear 'quaternion))
+        )
+    (set! (-> s5-1 y) 0.0)
+    (vector-normalize! s5-1 1.0)
+    (quaternion-set! gp-1 0.0 (-> s5-1 x) 0.0 (+ 1.0 (-> s5-1 z)))
+    (quaternion-normalize! gp-1)
+    (quaternion-slerp!
+      (-> self root-override2 quat)
+      (-> self root-override2 quat)
+      gp-1
+      (* 0.3 (-> self clock seconds-per-frame))
+      )
+    )
+  (nav-enemy-simple-post)
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior mammoth-walk-check-end mammoth ()
+  (let ((a1-1 (vector-! (new 'stack-no-clear 'vector) (-> self move-pos 1) (the-as vector (-> self move-pos))))
+        (gp-1
+          (vector-! (new 'stack-no-clear 'vector) (-> self root-override2 trans) (the-as vector (-> self move-pos)))
+          )
+        )
+    (if (< (vector-length a1-1) (vector-dot gp-1 (vector-normalize-copy! (new 'stack-no-clear 'vector) a1-1 1.0)))
+        (go-virtual turning)
+        )
+    )
+  (none)
+  )
+
+(defbehavior next-path-index mammoth ()
+  (cond
+    ((= (-> self path-index-dir) 1)
+     (if (= (-> self path-index) (the int (get-num-segments (-> self path))))
+         (set! (-> self path-index-dir) -1)
+         )
+     (+! (-> self path-index) (-> self path-index-dir))
+     )
+    (else
+      (if (zero? (-> self path-index))
+          (set! (-> self path-index-dir) 1)
+          )
+      (+! (-> self path-index) (-> self path-index-dir))
+      )
+    )
+  (let ((gp-0
+          (get-point-in-path! (-> self path) (new 'stack-no-clear 'vector) (the float (-> self path-index)) 'interp)
+          )
+        )
+    (cloest-point-on-mesh (-> self nav) gp-0 gp-0 (the-as nav-poly #f))
+    (set! (-> self move-pos 0 quad) (-> self move-pos 1 quad))
+    (set! (-> self move-pos 1 quad) (-> gp-0 quad))
+    )
+  0
+  (none)
+  )
+
+(defbehavior set-nav-destination mammoth ()
+  (let ((s5-1 (vector-! (new 'stack-no-clear 'vector) (-> self move-pos 1) (the-as vector (-> self move-pos))))
+        (s4-0 (new 'stack-no-clear 'vector))
+        (gp-0 (new 'stack-no-clear 'vector))
+        )
+    (vector-normalize! s5-1 65536.0)
+    (vector-line-distance-point!
+      (-> self root-override2 trans)
+      (the-as vector (-> self move-pos))
+      (-> self move-pos 1)
+      s4-0
+      )
+    (vector+! gp-0 s4-0 s5-1)
+    (cloest-point-on-mesh (-> self nav) gp-0 gp-0 (the-as nav-poly #f))
+    (set! (-> self travel-dest quad) (-> gp-0 quad))
+    )
+  (let ((a0-5 (-> self nav state))
+        (v1-8 (-> self travel-dest))
+        )
+    (logclear! (-> a0-5 flags) (nav-state-flag directional-mode))
+    (logior! (-> a0-5 flags) (nav-state-flag target-poly-dirty))
+    (set! (-> a0-5 target-post quad) (-> v1-8 quad))
+    )
+  0
+  (none)
+  )
+
+(defbehavior mammoth-walk-handler mammoth ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (local-vars (v0-0 object))
+  (case arg2
+    (('event-rl-down)
+     (set! v0-0 (logior (-> self foot-flags) 8))
+     (set! (-> self foot-flags) (the-as uint v0-0))
+     v0-0
+     )
+    (('event-rr-up)
+     (set! v0-0 (logand -5 (-> self foot-flags)))
+     (set! (-> self foot-flags) (the-as uint v0-0))
+     v0-0
+     )
+    (('event-fl-down)
+     (set! v0-0 (logior (-> self foot-flags) 1))
+     (set! (-> self foot-flags) (the-as uint v0-0))
+     v0-0
+     )
+    (('event-fr-up)
+     (set! v0-0 (logand -3 (-> self foot-flags)))
+     (set! (-> self foot-flags) (the-as uint v0-0))
+     v0-0
+     )
+    (('event-rr-down)
+     (set! v0-0 (logior (-> self foot-flags) 4))
+     (set! (-> self foot-flags) (the-as uint v0-0))
+     v0-0
+     )
+    (('event-rl-up)
+     (set! v0-0 (logand -9 (-> self foot-flags)))
+     (set! (-> self foot-flags) (the-as uint v0-0))
+     v0-0
+     )
+    (('event-fr-down)
+     (set! v0-0 (logior (-> self foot-flags) 2))
+     (set! (-> self foot-flags) (the-as uint v0-0))
+     v0-0
+     )
+    (('event-fl-up)
+     (set! v0-0 (logand -2 (-> self foot-flags)))
+     (set! (-> self foot-flags) (the-as uint v0-0))
+     v0-0
+     )
+    (else
+      (enemy-event-handler arg0 arg1 arg2 arg3)
+      )
+    )
+  )
+
+(defstate waiting (mammoth)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('cue-chase)
+       (go-virtual wait-to-walk)
+       )
+      )
+    )
+  :enter (behavior ()
+    (let ((v1-0 self))
+      (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logclear (-> v1-0 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-0 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (let ((v1-3 self))
+      (set! (-> v1-3 enemy-flags) (the-as enemy-flag (logclear (-> v1-3 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (logior! (-> self foot-flags) 15)
+    (none)
+    )
+  :code (behavior ()
+    (move-to-ground (-> self root-override2) 40960.0 122880.0 #t (collide-spec backgnd))
+    (dotimes (v1-2 4)
+      (set! (-> self ik-handle-pos v1-2 quad) (-> self root-override2 trans quad))
+      (set! (-> self ik-handle-y v1-2) (-> self root-override2 trans y))
+      )
+    (ja-channel-push! 1 (seconds 0.1))
+    (until #f
+      (ja-no-eval :group! mammoth-idle0-ja
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim mammoth-idle0-ja) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior mammoth) nav-enemy-simple-post)
+  )
+
+(defstate wait-to-walk (mammoth)
+  :virtual #t
+  :event mammoth-walk-handler
+  :enter (behavior ()
+    (nav-enemy-method-165 self)
+    (let ((v1-2 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-2 enemy-flags)))
+          (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-2 enemy-flags))))
+          )
+      (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-2 enemy-flags))))
+      (set! (-> v1-2 nav callback-info) (-> v1-2 enemy-info-override callback-info))
+      )
+    0
+    (let ((v1-5 self))
+      (set! (-> v1-5 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-5 enemy-flags))))
+      )
+    0
+    (none)
+    )
+  :code (behavior ()
+    (next-path-index)
+    (set-nav-destination)
+    (ja-channel-push! 1 (seconds 0.1))
+    (ja-no-eval :group! mammoth-idle0-to-walk-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mammoth-idle0-to-walk-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (go-virtual walking)
+    (none)
+    )
+  :post mammoth-walk-post
+  )
+
+(defstate walking (mammoth)
+  :virtual #t
+  :event mammoth-walk-handler
+  :enter (behavior ()
+    (nav-enemy-method-165 self)
+    (let ((v1-2 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-2 enemy-flags)))
+          (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-2 enemy-flags))))
+          )
+      (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-2 enemy-flags))))
+      (set! (-> v1-2 nav callback-info) (-> v1-2 enemy-info-override callback-info))
+      )
+    0
+    (let ((v1-5 self))
+      (set! (-> v1-5 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-5 enemy-flags))))
+      )
+    0
+    (logior! (-> self foot-flags) 6)
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.1))
+    (let ((v1-2 (ja-group)))
+      (when (not (or (and v1-2 (= v1-2 mammoth-walk0-ja))
+                     (let ((v1-8 (ja-group)))
+                       (and v1-8 (= v1-8 mammoth-walk1-ja))
+                       )
+                     (let ((v1-13 (ja-group)))
+                       (and v1-13 (= v1-13 mammoth-idle0-to-walk-ja))
+                       )
+                     )
+                 )
+        )
+      )
+    (until #f
+      (mammoth-walk-check-end)
+      (set-nav-destination)
+      (let ((v1-20 (if (rng-hit? self 0.5)
+                       6
+                       7
+                       )
+                   )
+            )
+        (ja-no-eval :group! (-> self draw art-group data v1-20)
+                    :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data v1-20)) frames num-frames) -1)))
+                    :frame-num 0.0
+                    )
+        )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      (mammoth-walk-check-end)
+      (when (>= (- (-> self clock frame-counter) (-> self attack-timer)) (seconds 5))
+        (set! (-> self attack-timer) (-> self clock frame-counter))
+        (go-virtual walking-attack)
+        )
+      )
+    #f
+    (none)
+    )
+  :post mammoth-walk-post
+  )
+
+(defstate walking-attack (mammoth)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('event-attack)
+       (let ((v0-0 (the-as object (-> self clock frame-counter))))
+         (set! (-> self lightning-timer) (the-as time-frame v0-0))
+         v0-0
+         )
+       )
+      (else
+        (mammoth-walk-handler proc arg1 event-type event)
+        )
+      )
+    )
+  :enter (behavior ()
+    (nav-enemy-method-165 self)
+    (let ((v1-2 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-2 enemy-flags)))
+          (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-2 enemy-flags))))
+          )
+      (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-2 enemy-flags))))
+      (set! (-> v1-2 nav callback-info) (-> v1-2 enemy-info-override callback-info))
+      )
+    0
+    (let ((v1-5 self))
+      (set! (-> v1-5 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-5 enemy-flags))))
+      )
+    0
+    (logior! (-> self foot-flags) 6)
+    (none)
+    )
+  :trans (behavior ()
+    (when (and (< (- (-> self clock frame-counter) (-> self lightning-timer)) (seconds 3))
+               (< (-> self spawn-timer) (-> self clock frame-counter))
+               )
+      (let ((s5-0 *mammoth-lightning-joint-tbl*))
+        (mammoth-method-185 self (-> self root-override2 trans) (-> s5-0 (get-rand-int self (-> s5-0 length))))
+        )
+      (set! (-> self spawn-timer)
+            (+ (-> self clock frame-counter) (the int (* 300.0 (get-rand-float-range self 0.0 0.1))))
+            )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (set-nav-destination)
+    (ja-channel-push! 1 (seconds 0.1))
+    (ja-no-eval :group! mammoth-walk-fire0-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mammoth-walk-fire0-ja) frames num-frames) -1)) 0.8)
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! max 0.8))
+      )
+    (until #f
+      (mammoth-walk-check-end)
+      (set-nav-destination)
+      (ja-no-eval :group! mammoth-walk0-ja
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim mammoth-walk0-ja) frames num-frames) -1)) 0.8)
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max 0.8))
+        )
+      (mammoth-walk-check-end)
+      (when (>= (- (-> self clock frame-counter) (-> self attack-timer)) (seconds 3))
+        (set! (-> self attack-timer) (-> self clock frame-counter))
+        (go-virtual walking)
+        )
+      )
+    #f
+    (none)
+    )
+  :post mammoth-walk-post
+  )
+
+(defstate turning (mammoth)
+  :virtual #t
+  :event mammoth-walk-handler
+  :enter (behavior ()
+    (next-path-index)
+    (let ((gp-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat)))
+          (s5-0 (new 'stack-no-clear 'vector))
+          )
+      (set! (-> gp-0 y) 0.0)
+      (vector-xz-normalize! gp-0 1.0)
+      (vector-! s5-0 (-> self move-pos 1) (-> self root-override2 trans))
+      (set! (-> s5-0 y) 0.0)
+      (vector-xz-normalize! s5-0 1.0)
+      (set! (-> self turn-angle) (deg- (vector-y-angle s5-0) (vector-y-angle gp-0)))
+      )
+    (cond
+      ((< 23665.777 (-> self turn-angle))
+       (set! (-> self turn-anim-start) 14)
+       (set! (-> self turn-anim) 15)
+       (set! (-> self turn-anim-end) -1)
+       (set! (-> self turn-move-start) 20480.0)
+       (set! (-> self turn-move-end) 0.0)
+       (set! (-> self turn-angle) 27306.666)
+       )
+      ((< 5461.3335 (-> self turn-angle))
+       (set! (-> self turn-anim-start) 12)
+       (set! (-> self turn-anim) 13)
+       (set! (-> self turn-anim-end) -1)
+       (set! (-> self turn-move-start) 10240.0)
+       (set! (-> self turn-move-end) 0.0)
+       (set! (-> self turn-angle) 9102.223)
+       )
+      ((< -5461.3335 (-> self turn-angle))
+       (set! (-> self turn-anim-start) -1)
+       (set! (-> self turn-anim) -1)
+       (set! (-> self turn-anim-end) -1)
+       (set! (-> self turn-move-start) 0.0)
+       (set! (-> self turn-move-end) 0.0)
+       (set! (-> self turn-angle) 0.0)
+       )
+      ((< -23665.777 (-> self turn-angle))
+       (set! (-> self turn-anim-start) -1)
+       (set! (-> self turn-anim) 16)
+       (set! (-> self turn-anim-end) -1)
+       (set! (-> self turn-move-start) 0.0)
+       (set! (-> self turn-move-end) 0.0)
+       (set! (-> self turn-angle) -9102.223)
+       )
+      (else
+        (set! (-> self turn-anim-start) -1)
+        (set! (-> self turn-anim) 17)
+        (set! (-> self turn-anim-end) 18)
+        (set! (-> self turn-move-start) 0.0)
+        (set! (-> self turn-move-end) -10240.0)
+        (set! (-> self turn-angle) -27306.666)
+        )
+      )
+    (let ((v1-33 self))
+      (set! (-> v1-33 enemy-flags) (the-as enemy-flag (logclear (-> v1-33 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.1))
+    (when (!= (-> self turn-anim-start) -1)
+      (let ((gp-0 (-> self draw art-group data (-> self turn-anim-start))))
+        (let ((v1-7 (vector-z-quaternion! (-> self root-override2 transv) (-> self root-override2 quat)))
+              (a0-6 (-> self root-override2 trans))
+              )
+          (set! (-> (new 'stack-no-clear 'vector) quad) (-> a0-6 quad))
+          (vector+float*! (new 'stack-no-clear 'vector) a0-6 v1-7 (-> self turn-move-start))
+          )
+        (ja-no-eval :group! gp-0
+                    :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) 0.6667)
+                    :frame-num 0.0
+                    )
+        )
+      (until (ja-done? 0)
+        (compute-alignment! (-> self align))
+        (align! (-> self align) (align-opts adjust-xz-vel adjust-quat) 1.0 1.0 1.0)
+        (suspend)
+        (ja :num! (seek! max 0.6667))
+        )
+      )
+    (when (!= (-> self turn-anim) -1)
+      (ja-no-eval :group! (-> self draw art-group data (-> self turn-anim))
+                  :num! (seek!
+                    (the float
+                         (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self turn-anim))) frames num-frames) -1)
+                         )
+                    0.6667
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (compute-alignment! (-> self align))
+        (align! (-> self align) (align-opts adjust-xz-vel adjust-quat) 1.0 1.0 1.0)
+        (suspend)
+        (ja :num! (seek! max 0.6667))
+        )
+      )
+    (when (!= (-> self turn-anim-end) -1)
+      (let ((gp-1 (-> self draw art-group data (-> self turn-anim-end))))
+        (let ((v1-68 (vector-z-quaternion! (-> self root-override2 transv) (-> self root-override2 quat)))
+              (a0-23 (-> self root-override2 trans))
+              )
+          (set! (-> (new 'stack-no-clear 'vector) quad) (-> a0-23 quad))
+          (vector+float*! (new 'stack-no-clear 'vector) a0-23 v1-68 (-> self turn-move-end))
+          )
+        (ja-no-eval :group! gp-1
+                    :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-1) frames num-frames) -1)) 0.6667)
+                    :frame-num 0.0
+                    )
+        )
+      (until (ja-done? 0)
+        (compute-alignment! (-> self align))
+        (align! (-> self align) (align-opts adjust-xz-vel adjust-quat) 1.0 1.0 1.0)
+        (suspend)
+        (ja :num! (seek! max 0.6667))
+        )
+      )
+    (go-virtual walking)
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-simple-post)
+    (none)
+    )
+  )
+
+(defstate die (mammoth)
+  :virtual #t
+  :code (behavior ()
+    (set-nav-destination)
+    (ja-no-eval :group! mammoth-death-right-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mammoth-death-right-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (ja-no-eval :group! mammoth-death-right-fall-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mammoth-death-right-fall-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (ja-no-eval :group! mammoth-death-right-fall-end-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mammoth-death-right-fall-end-ja) 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)
+    )
+  :post mammoth-walk-post
+  )
+
+(defmethod enemy-method-74 mammoth ((obj mammoth) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (case arg2
+    (('hit)
+     (logclear! (-> obj mask) (process-mask actor-pause))
+     (logclear! (-> obj focus-status) (focus-status dangerous))
+     (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice))
+     (logior! (-> obj enemy-flags) (enemy-flag chase-startup))
+     (logior! (-> obj focus-status) (focus-status hit))
+     (if (zero? (-> obj hit-points))
+         (logior! (-> obj focus-status) (focus-status dead))
+         )
+     (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup))
+     (enemy-method-62 obj)
+     (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
+     (process-contact-action arg0)
+     (send-event arg0 'get-attack-count 1)
+     )
+    (else
+      ((method-of-type nav-enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+      )
+    )
+  )
+
+(defmethod mammoth-method-185 mammoth ((obj mammoth) (arg0 vector) (arg1 int))
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         (vf7 :class vf)
+         )
+    (init-vf0-vector)
+    (let ((s1-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data arg1)))
+          (s2-0 (new 'stack-no-clear 'vector))
+          )
+      (let ((s4-1
+              (vector-normalize! (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)) 16384.0)
+              )
+            )
+        (vector-! s2-0 s1-0 arg0)
+        (set! (-> s2-0 y) 0.0)
+        (vector-xz-normalize! s2-0 49152.0)
+        (set! (-> s2-0 y) (+ -81920.0 (-> s2-0 y)))
+        (vector+! s2-0 s2-0 s4-1)
+        )
+      (let ((s3-1 (new 'stack-no-clear 'collide-query))
+            (s4-2 (new 'stack-no-clear 'matrix))
+            )
+        (matrix->trans (-> obj node-list data arg1 bone transform) (-> s3-1 start-pos))
+        (set! (-> s3-1 move-dist quad) (-> s2-0 quad))
+        (let ((v1-11 s3-1))
+          (set! (-> v1-11 radius) 4.096)
+          (set! (-> v1-11 collide-with) (collide-spec backgnd obstacle))
+          (set! (-> v1-11 ignore-process0) #f)
+          (set! (-> v1-11 ignore-process1) #f)
+          (set! (-> v1-11 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+          (set! (-> v1-11 action-mask) (collide-action solid))
+          )
+        (fill-using-line-sphere *collide-cache* s3-1)
+        (let ((f0-4 (probe-using-line-sphere *collide-cache* s3-1)))
+          (when (>= f0-4 0.0)
+            (let ((a0-16 s4-2))
+              (let ((v1-17 (-> s3-1 start-pos)))
+                (let ((a1-9 (-> s3-1 move-dist)))
+                  (let ((a2-1 f0-4))
+                    (.mov vf7 a2-1)
+                    )
+                  (.lvf vf5 (&-> a1-9 quad))
+                  )
+                (.lvf vf4 (&-> v1-17 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-16 quad 0) vf6)
+              )
+            (process-spawn
+              lightning-tracker
+              :init lightning-tracker-init
+              (-> *lightning-spec-id-table* 1)
+              600
+              #f
+              obj
+              arg1
+              s4-2
+              :to *entity-pool*
+              )
+            )
+          )
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod go-stare mammoth ((obj mammoth))
+  (go (method-of-object obj walking))
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod go-hostile mammoth ((obj mammoth))
+  (go (method-of-object obj walking))
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod go-idle mammoth ((obj mammoth))
+  (go (method-of-object obj waiting))
+  (none)
+  )
+
+;; WARN: Return type mismatch symbol vs pat-surface.
+(defmethod enemy-method-125 mammoth ((obj mammoth) (arg0 collide-query) (arg1 collide-spec) (arg2 float) (arg3 float) (arg4 float))
+  (with-pp
+    (the-as
+      pat-surface
+      (when (find-ground (-> obj root-override2) arg0 arg1 arg2 arg3 arg4)
+        (set! (-> obj root-override2 ground-pat) (-> arg0 best-other-tri pat))
+        (let ((s3-0 (new 'stack-no-clear 'collide-query)))
+          (let ((s2-1
+                  (vector-! (new 'stack-no-clear 'vector) (-> obj root-override2 gspot-pos) (-> obj root-override2 trans))
+                  )
+                )
+            (vector-normalize! s2-1 1.0)
+            (vector+float*! (-> s3-0 start-pos) (-> obj root-override2 gspot-pos) s2-1 -4096.0)
+            (vector-float*! (-> s3-0 move-dist) s2-1 8192.0)
+            )
+          (let ((v1-9 s3-0))
+            (set! (-> v1-9 radius) 8192.0)
+            (set! (-> v1-9 collide-with) arg1)
+            (set! (-> v1-9 ignore-process0) obj)
+            (set! (-> v1-9 ignore-process1) #f)
+            (set! (-> v1-9 ignore-pat) (-> obj root-override2 pat-ignore-mask))
+            (set! (-> v1-9 action-mask) (collide-action solid))
+            )
+          (fill-using-line-sphere *collide-cache* s3-0)
+          )
+        (let ((s4-1 (new 'stack-no-clear 'vector)))
+          (vector-reset! s4-1)
+          (dotimes (s3-1 (-> *collide-cache* num-tris))
+            (let* ((v1-15 (-> *collide-cache* tris s3-1))
+                   (s1-1 (vector-! (new 'stack-no-clear 'vector) (-> v1-15 vertex 1) (the-as vector (-> v1-15 vertex))))
+                   (s0-1 (vector-! (new 'stack-no-clear 'vector) (-> v1-15 vertex 2) (the-as vector (-> v1-15 vertex))))
+                   (s2-2 (new 'stack-no-clear 'vector))
+                   )
+              (vector-normalize! s1-1 1.0)
+              (vector-normalize! s0-1 1.0)
+              (vector-cross! s2-2 s1-1 s0-1)
+              (if (< (cos 10922.667) (vector-dot s2-2 *y-vector*))
+                  (vector+! s4-1 s4-1 s2-2)
+                  )
+              )
+            )
+          (vector-normalize-copy! (-> obj gspot-normal) s4-1 1.0)
+          )
+        (let ((f0-4 (-> obj root-override2 gspot-pos y)))
+          (if (= (-> obj y-level) -40959590.0)
+              (set! (-> obj y-level) f0-4)
+              (seek! (-> obj y-level) f0-4 (* 8192.0 (-> pp clock seconds-per-frame)))
+              )
+          )
+        (set! (-> obj root-override2 gspot-pos y) (-> obj y-level))
+        (set! (-> arg0 best-other-tri intersect y) (-> obj y-level))
+        #t
+        )
+      )
+    )
+  )
+
+(defmethod mammoth-method-183 mammoth ((obj mammoth))
+  (with-pp
+    (cond
+      ((= (-> obj root-override2 gspot-pos y) -40959590.0)
+       (quaternion-copy! (-> obj tilt-quat) *unity-quaternion*)
+       )
+      (else
+        (let ((s1-0 (-> obj root-override2 trans))
+              (s5-0 (new 'stack-no-clear 'vector))
+              )
+          (set! (-> s5-0 quad) (-> obj gspot-normal quad))
+          (let ((s4-0 (new 'stack-no-clear 'vector)))
+            (set! (-> s4-0 quad) (-> obj gspot-normal quad))
+            (let ((s3-0 (new 'stack-no-clear 'vector)))
+              (set! (-> s3-0 quad) (-> obj gspot-normal quad))
+              (let ((s2-0 (new 'stack-no-clear 'vector)))
+                (set! (-> s2-0 quad) (-> obj gspot-normal quad))
+                (let ((s0-0 (lambda ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 vector))
+                              (let ((gp-1 (vector-! (new 'stack-no-clear 'vector) arg2 arg1))
+                                    (s4-1 (vector-! (new 'stack-no-clear 'vector) arg3 arg1))
+                                    )
+                                (vector-normalize! gp-1 1.0)
+                                (vector-normalize! s4-1 1.0)
+                                (vector-cross! arg0 s4-1 gp-1)
+                                )
+                              )
+                            )
+                      )
+                  (if (and (logtest? (-> obj foot-flags) 1) (logtest? (-> obj foot-flags) 2))
+                      (s0-0 s5-0 s1-0 (the-as vector (-> obj foot-pos)) (-> obj foot-pos 1))
+                      )
+                  (if (and (logtest? (-> obj foot-flags) 2) (logtest? (-> obj foot-flags) 4))
+                      (s0-0 s4-0 s1-0 (-> obj foot-pos 1) (-> obj foot-pos 2))
+                      )
+                  (if (and (logtest? (-> obj foot-flags) 4) (logtest? (-> obj foot-flags) 8))
+                      (s0-0 s4-0 s1-0 (-> obj foot-pos 2) (-> obj foot-pos 3))
+                      )
+                  (if (and (logtest? (-> obj foot-flags) 8) (logtest? (-> obj foot-flags) 1))
+                      (s0-0 s4-0 s1-0 (-> obj foot-pos 3) (the-as vector (-> obj foot-pos)))
+                      )
+                  )
+                (vector+! s5-0 s5-0 s4-0)
+                (vector+! s5-0 s5-0 s3-0)
+                (vector+! s5-0 s5-0 s2-0)
+                )
+              )
+            )
+          (vector-normalize! s5-0 1.0)
+          (let ((s4-1 (new 'stack-no-clear 'quaternion)))
+            (let ((s0-1 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat))))
+              (set! (-> s0-1 y) 0.0)
+              (vector-xz-normalize! s0-1 1.0)
+              (vector-rotate-y! s5-0 s5-0 (- (vector-y-angle s0-1)))
+              )
+            (quaternion-from-two-vectors-max-angle! s4-1 *up-vector* s5-0 4551.1113)
+            (quaternion-slerp! (-> obj tilt-quat) (-> obj tilt-quat) s4-1 (* 0.5 (-> pp clock seconds-per-frame)))
+            )
+          )
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+(defun mammoth-joint-mod-tilt ((arg0 cspace) (arg1 transformq))
+  (-> arg0 param1)
+  (cspace<-parented-transformq-joint! arg0 arg1)
+  (none)
+  )
+
+;; WARN: Return type mismatch vector vs none.
+(defun mammoth-joint-mod-heel ((arg0 cspace) (arg1 transformq))
+  (let* ((s0-0 (-> arg0 param1))
+         (f30-0 (-> (the-as mammoth (+ (* (the-as int (-> arg0 param2)) 4) (the-as int s0-0))) heel-lerp 0))
+         (s3-0 (new 'stack-no-clear 'quaternion))
+         )
+    (cspace<-parented-transformq-joint! arg0 arg1)
+    (let ((s4-0 (new 'stack-no-clear 'vector))
+          (s5-0 (new 'stack-no-clear 'vector))
+          )
+      (let ((s2-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> (the-as mammoth s0-0) root-override2 quat)))
+            (s1-0 (new 'stack-no-clear 'vector))
+            )
+        (set! (-> s1-0 quad) (-> (the-as mammoth s0-0) my-up-vector quad))
+        (let ((v1-6 (-> arg0 param2)))
+          (cond
+            ((zero? v1-6)
+             (vector-negate! s1-0 s1-0)
+             )
+            ((= v1-6 1)
+             (vector-negate! s2-0 s2-0)
+             )
+            ((= v1-6 2)
+             (vector-negate! s1-0 s1-0)
+             )
+            ((= v1-6 3)
+             (vector-negate! s2-0 s2-0)
+             )
+            )
+          )
+        (let ((s2-1 (forward-up->quaternion (new 'stack-no-clear 'quaternion) s2-0 s1-0)))
+          (matrix->scale (-> arg0 bone transform) s4-0)
+          (set! (-> s5-0 quad) (-> arg0 bone transform trans quad))
+          (matrix-with-scale->quaternion s3-0 (-> arg0 bone transform))
+          (quaternion-normalize! s3-0)
+          (quaternion-slerp! s3-0 s2-1 s3-0 f30-0)
+          )
+        )
+      (quaternion->matrix (-> arg0 bone transform) s3-0)
+      (scale-matrix! (-> arg0 bone transform) s4-0 (-> arg0 bone transform))
+      (set! (-> arg0 bone transform trans quad) (-> s5-0 quad))
+      )
+    )
+  (none)
+  )
+
+;; WARN: Return type mismatch none vs object.
+(defun mammoth-leg-ik-callback ((arg0 joint-mod-ik) (arg1 matrix) (arg2 matrix) (arg3 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 ((s5-0 (new 'stack-no-clear 'vector)))
+        (set! (-> s5-0 quad) (-> arg3 quad))
+        (let ((f30-0 (- (-> arg3 y) (-> arg0 process root trans y))))
+          (if (< 6144.0 f30-0)
+              (set! f30-0 6144.0)
+              )
+          (if (< f30-0 -6144.0)
+              (set! f30-0 -6144.0)
+              )
+          (let ((s2-0 (-> arg0 user-position)))
+            (let ((s3-0 (-> arg0 user-position)))
+              (let ((v1-14 (vector-y-quaternion! (new 'stack-no-clear 'vector) (-> arg0 process root quat))))
+                (let ((a0-2 f30-0))
+                  (.mov vf7 a0-2)
+                  )
+                (.lvf vf5 (&-> v1-14 quad))
+                )
+              (.lvf vf4 (&-> s3-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 (&-> s2-0 quad) vf6)
+            )
+          )
+        (let ((f0-4 (- (-> arg3 y) (-> arg0 user-position y))))
+          (seek! (-> arg0 user-float) f0-4 (* 40960.0 (-> pp clock seconds-per-frame)))
+          )
+        (let* ((f0-8 (-> arg0 user-float))
+               (f30-1 (lerp-scale 1.0 0.0 f0-8 0.0 12288.0))
+               (s3-1 (new 'stack-no-clear 'vector))
+               )
+          (let ((v1-17 s5-0))
+            (let ((a0-5 (-> arg0 user-normal)))
+              (let ((a1-5 8192.0))
+                (.mov vf7 a1-5)
+                )
+              (.lvf vf5 (&-> a0-5 quad))
+              )
+            (.lvf vf4 (&-> v1-17 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 (&-> s3-1 quad) vf6)
+          (vector-float*! (new 'stack-no-clear 'vector) (-> arg0 user-normal) -16384.0)
+          (let ((s4-1 (new 'stack-no-clear 'vector)))
+            0.0
+            (let ((f0-12 (intersect-ray-plane s3-1 (-> arg0 user-normal) (-> arg0 user-position) *up-vector*))
+                  (a0-8 s4-1)
+                  )
+              (let ((v1-20 (-> arg0 user-normal)))
+                (let ((a1-8 f0-12))
+                  (.mov vf7 a1-8)
+                  )
+                (.lvf vf5 (&-> v1-20 quad))
+                )
+              (.lvf vf4 (&-> s3-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 (&-> a0-8 quad) vf6)
+              )
+            (let ((a1-9 s4-1))
+              (let ((v1-21 s4-1))
+                (let ((a0-9 (-> arg0 user-normal)))
+                  (let ((a2-7
+                          (- (vector-dot (-> arg0 user-normal) (vector-! (new 'stack-no-clear 'vector) s4-1 (-> arg0 user-position))))
+                          )
+                        )
+                    (.mov vf7 a2-7)
+                    )
+                  (.lvf vf5 (&-> a0-9 quad))
+                  )
+                (.lvf vf4 (&-> v1-21 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-9 quad) vf6)
+              )
+            (let ((a1-10 s5-0))
+              (let ((v1-22 s5-0))
+                (let ((a0-11 (vector-! (new 'stack-no-clear 'vector) s4-1 s5-0)))
+                  (let ((a2-10 (fmin 1.0 (* (-> arg0 user-blend) f30-1))))
+                    (.mov vf7 a2-10)
+                    )
+                  (.lvf vf5 (&-> a0-11 quad))
+                  )
+                (.lvf vf4 (&-> v1-22 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-10 quad) vf6)
+              )
+            )
+          )
+        (the-as object (handle-copy! arg0 s5-0))
+        )
+      )
+    )
+  )
+
+(defbehavior mammoth-update-ik mammoth ()
+  (local-vars (sv-688 vector))
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         (vf7 :class vf)
+         )
+    (init-vf0-vector)
+    (let ((gp-0 (new 'stack-no-clear 'collide-query))
+          (s5-0 (-> self root-override2))
+          )
+      (dotimes (s4-0 4)
+        (let ((s3-0 (-> self joint-ik s4-0)))
+          #t
+          (set! (-> s3-0 callback) mammoth-leg-ik-callback)
+          (-> s3-0 shoulder-matrix-no-ik)
+          (let ((v1-5 (-> s3-0 elbow-matrix-no-ik))
+                (s0-0 (new 'stack-no-clear 'vector))
+                )
+            (set! sv-688 (new 'stack-no-clear 'vector))
+            (let ((a0-2 (-> *y-vector* quad)))
+              (set! (-> sv-688 quad) a0-2)
+              )
+            (let ((s2-0 (new 'stack-no-clear 'vector)))
+              (new 'stack-no-clear 'vector)
+              (new 'stack-no-clear 'vector)
+              (let ((s1-0 (new 'stack-no-clear 'vector)))
+                (let ((a1-1 s0-0))
+                  (let ((a0-5 (-> v1-5 trans)))
+                    (let ((v1-6 (-> v1-5 vector 1)))
+                      (let ((a2-0 (-> s3-0 hand-dist)))
+                        (.mov vf7 a2-0)
+                        )
+                      (.lvf vf5 (&-> v1-6 quad))
+                      )
+                    (.lvf vf4 (&-> a0-5 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-1 quad) vf6)
+                  )
+                (let ((a1-2 (-> gp-0 bbox))
+                      (v1-7 s0-0)
+                      (a0-6 (new 'stack-no-clear 'vector))
+                      )
+                  (set! (-> a0-6 x) 10240.0)
+                  (set! (-> a0-6 y) 14336.0)
+                  (set! (-> a0-6 z) 10240.0)
+                  (set! (-> a0-6 w) 1.0)
+                  (vector-! (the-as vector a1-2) v1-7 a0-6)
+                  )
+                (let ((a1-4 (-> gp-0 bbox max))
+                      (v1-8 s0-0)
+                      (a0-7 (new 'stack-no-clear 'vector))
+                      )
+                  (set! (-> a0-7 x) 10240.0)
+                  (set! (-> a0-7 y) 6144.0)
+                  (set! (-> a0-7 z) 10240.0)
+                  (set! (-> a0-7 w) 1.0)
+                  (vector+! a1-4 v1-8 a0-7)
+                  )
+                (set! (-> gp-0 collide-with) (collide-spec backgnd))
+                (set! (-> gp-0 ignore-process0) #f)
+                (set! (-> gp-0 ignore-process1) #f)
+                (fill-using-bounding-box *collide-cache* gp-0)
+                (let ((f0-11 (lerp-scale 1.0 0.0 (- (-> s0-0 y) (-> s5-0 gspot-pos y)) 2048.0 12288.0)))
+                  (seek! (-> s3-0 user-blend) f0-11 (* 4.0 (-> self clock seconds-per-frame)))
+                  )
+                (let ((a1-9 (-> gp-0 start-pos)))
+                  (let ((v1-14 s0-0))
+                    (let ((a0-11 sv-688))
+                      (let ((a2-12 12288.0))
+                        (.mov vf7 a2-12)
+                        )
+                      (.lvf vf5 (&-> a0-11 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-9 quad) vf6)
+                  )
+                (let ((v1-15 (-> gp-0 move-dist))
+                      (f0-16 -40960.0)
+                      )
+                  (vector-float*! v1-15 sv-688 f0-16)
+                  )
+                (let ((v1-17 gp-0))
+                  (set! (-> v1-17 radius) 4.096)
+                  (set! (-> v1-17 collide-with) (-> gp-0 collide-with))
+                  (set! (-> v1-17 ignore-process0) #f)
+                  (set! (-> v1-17 ignore-process1) #f)
+                  (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))
+                  )
+                (let ((f0-18 (probe-using-line-sphere *collide-cache* gp-0)))
+                  (cond
+                    ((>= f0-18 0.0)
+                     (set! (-> s1-0 quad) (-> gp-0 best-other-tri normal quad))
+                     (let ((a1-11 s2-0))
+                       (let ((v1-20 (-> gp-0 start-pos)))
+                         (let ((a0-21 (-> gp-0 move-dist)))
+                           (let ((a2-13 f0-18))
+                             (.mov vf7 a2-13)
+                             )
+                           (.lvf vf5 (&-> a0-21 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-11 quad) vf6)
+                       )
+                     (set! (-> s3-0 user-position quad) (-> s2-0 quad))
+                     (set! (-> s3-0 user-normal quad) (-> s1-0 quad))
+                     )
+                    (else
+                      (set! (-> s0-0 y) (-> self root-override2 trans y))
+                      (set! (-> s3-0 user-position quad) (-> s0-0 quad))
+                      (set! (-> s3-0 user-normal quad) (-> *y-vector* quad))
+                      )
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+(defmethod mammoth-method-184 mammoth ((obj mammoth))
+  (with-pp
+    (rlet ((acc :class vf)
+           (vf0 :class vf)
+           (vf4 :class vf)
+           (vf5 :class vf)
+           (vf6 :class vf)
+           (vf7 :class vf)
+           )
+      (init-vf0-vector)
+      (dotimes (s5-0 4)
+        (-> obj joint-ik s5-0 shoulder-matrix-no-ik)
+        (let ((a0-1 (-> obj joint-ik s5-0 elbow-matrix-no-ik))
+              (s3-0 (-> *mammoth-ik-setup* s5-0))
+              (v1-8 (new 'stack-no-clear 'vector))
+              (s1-0 (new 'stack-no-clear 'vector))
+              )
+          (set! (-> s1-0 quad) (-> *y-vector* quad))
+          (new 'stack-no-clear 'vector)
+          (let ((s4-0 (new 'stack-no-clear 'vector)))
+            (let ((a2-0 v1-8))
+              (let ((a1-4 (-> a0-1 trans)))
+                (let ((a0-2 (-> a0-1 vector 1)))
+                  (let ((a3-0 (-> s3-0 hand-dist)))
+                    (.mov vf7 a3-0)
+                    )
+                  (.lvf vf5 (&-> a0-2 quad))
+                  )
+                (.lvf vf4 (&-> a1-4 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 (&-> a2-0 quad) vf6)
+              )
+            (set! (-> s4-0 quad) (-> v1-8 quad))
+            (let ((s2-0 (new 'stack-no-clear 'collide-query))
+                  (f30-0 (- (- (-> s4-0 y) (-> s3-0 ground-dist)) (-> obj root-override2 trans y)))
+                  )
+              (when #t
+                (let ((a1-5 (-> s2-0 bbox))
+                      (v1-13 s4-0)
+                      (a0-4 (new 'stack-no-clear 'vector))
+                      )
+                  (set! (-> a0-4 x) 16384.0)
+                  (set! (-> a0-4 y) 16384.0)
+                  (set! (-> a0-4 z) 16384.0)
+                  (set! (-> a0-4 w) 1.0)
+                  (vector-! (the-as vector a1-5) v1-13 a0-4)
+                  )
+                (let ((a1-7 (-> s2-0 bbox max))
+                      (v1-14 s4-0)
+                      (a0-5 (new 'stack-no-clear 'vector))
+                      )
+                  (set! (-> a0-5 x) 16384.0)
+                  (set! (-> a0-5 y) 16384.0)
+                  (set! (-> a0-5 z) 16384.0)
+                  (set! (-> a0-5 w) 1.0)
+                  (vector+! a1-7 v1-14 a0-5)
+                  )
+                (set! (-> s2-0 collide-with) (collide-spec backgnd))
+                (set! (-> s2-0 ignore-process0) #f)
+                (set! (-> s2-0 ignore-process1) #f)
+                (set! (-> s2-0 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+                (fill-using-bounding-box *collide-cache* s2-0)
+                (let ((a1-10 (-> s2-0 start-pos)))
+                  (let ((v1-19 s4-0))
+                    (let ((a0-7 s1-0))
+                      (let ((a2-10 24576.0))
+                        (.mov vf7 a2-10)
+                        )
+                      (.lvf vf5 (&-> a0-7 quad))
+                      )
+                    (.lvf vf4 (&-> v1-19 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-10 quad) vf6)
+                  )
+                (vector-float*! (-> s2-0 move-dist) s1-0 -49152.0)
+                (let ((v1-22 s2-0))
+                  (set! (-> v1-22 radius) (-> s3-0 ground-dist))
+                  (set! (-> v1-22 collide-with) (collide-spec backgnd))
+                  (set! (-> v1-22 ignore-process0) #f)
+                  (set! (-> v1-22 ignore-process1) #f)
+                  (set! (-> v1-22 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+                  (set! (-> v1-22 action-mask) (collide-action solid))
+                  )
+                (let ((f0-14 (probe-using-line-sphere *collide-cache* s2-0)))
+                  (when (>= f0-14 0.0)
+                    (let ((v1-26 (new 'stack-no-clear 'vector)))
+                      (let ((a0-13 (-> s2-0 start-pos)))
+                        (let ((a1-12 (-> s2-0 move-dist)))
+                          (let ((a2-11 f0-14))
+                            (.mov vf7 a2-11)
+                            )
+                          (.lvf vf5 (&-> a1-12 quad))
+                          )
+                        (.lvf vf4 (&-> a0-13 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-26 quad) vf6)
+                      (seek! (-> obj ik-handle-y s5-0) (-> v1-26 y) (* 16384.0 (-> pp clock seconds-per-frame)))
+                      )
+                    )
+                  )
+                (set! (-> s4-0 y) (+ (-> obj ik-handle-y s5-0) f30-0))
+                )
+              (set! (-> obj heel-lerp s5-0) (lerp-scale 0.0 1.0 f30-0 0.0 3072.0))
+              )
+            (handle-copy! (-> obj joint-ik s5-0) s4-0)
+            )
+          )
+        )
+      0
+      (none)
+      )
+    )
+  )
+
+(defmethod enemy-method-55 mammoth ((obj mammoth))
+  (local-vars (sv-752 lightning-spec) (sv-768 int) (sv-784 symbol) (sv-800 mammoth))
+  (with-pp
+    (let ((t9-0 (method-of-type nav-enemy enemy-method-55)))
+      (t9-0 obj)
+      )
+    (mammoth-update-ik)
+    (dotimes (s5-0 4)
+      (enable-set! (-> obj joint-ik s5-0) (zero? (-> obj draw cur-lod)))
+      )
+    (when (!= (-> obj old-foot-flags) (-> obj foot-flags))
+      (let ((s5-1 (new 'static 'array uint32 4 #xa #xd #x1c #x19)))
+        (dotimes (s4-0 4)
+          (let ((s3-0 (vector<-cspace!
+                        (new 'stack-no-clear 'vector)
+                        (-> obj node-list data (-> (the-as (pointer int32) (&+ s5-1 (* s4-0 4)))))
+                        )
+                      )
+                (s2-0 (new 'stack-no-clear 'collide-query))
+                )
+            (when (logtest? (ash 1 s4-0) (-> obj foot-flags))
+              (when (not (logtest? (ash 1 s4-0) (-> obj old-foot-flags)))
+                (set! (-> s2-0 start-pos quad) (-> s3-0 quad))
+                (vector-reset! (-> s2-0 move-dist))
+                (set! (-> s2-0 start-pos y) (+ 8192.0 (-> s2-0 start-pos y)))
+                (set! (-> s2-0 move-dist y) -40960.0)
+                (let ((v1-27 s2-0))
+                  (set! (-> v1-27 radius) 2048.0)
+                  (set! (-> v1-27 collide-with) (-> obj enemy-info-override gnd-collide-with))
+                  (set! (-> v1-27 ignore-process0) obj)
+                  (set! (-> v1-27 ignore-process1) #f)
+                  (set! (-> v1-27 ignore-pat) (-> obj root-override2 pat-ignore-mask))
+                  (set! (-> v1-27 action-mask) (collide-action solid))
+                  )
+                (if (>= (fill-and-probe-using-line-sphere *collide-cache* s2-0) 0.0)
+                    (set! (-> s3-0 y) (-> s2-0 best-other-tri intersect y))
+                    )
+                (set! (-> obj foot-pos s4-0 quad) (-> s3-0 quad))
+                )
+              )
+            )
+          )
+        )
+      (set! (-> obj old-foot-flags) (-> obj foot-flags))
+      )
+    (dotimes (v1-37 4)
+      (when (logtest? (ash 1 v1-37) (-> obj foot-flags))
+        )
+      )
+    (when (and (< (- (-> pp clock frame-counter) (-> obj lightning-timer)) (seconds 3))
+               (< (-> obj lightning-attack-timer) (-> pp clock frame-counter))
+               )
+      (let ((s5-2 *target*))
+        (when s5-2
+          (let* ((v1-47 (get-trans s5-2 0))
+                 (s0-1 (vector-! (new 'stack-no-clear 'vector) v1-47 (-> obj root-override2 trans)))
+                 )
+            (when (< (vector-length s0-1) 57344.0)
+              (let ((s4-1 (new 'stack-no-clear 'event-message-block)))
+                (set! (-> s4-1 from) (process->ppointer pp))
+                (set! (-> s4-1 num-params) 2)
+                (set! (-> s4-1 message) 'attack)
+                (set! (-> s4-1 param 0) (the-as uint #f))
+                (let ((s3-1 (new 'static 'attack-info :mask (attack-info-mask vector shove-back shove-up control id))))
+                  (let* ((a0-38 *game-info*)
+                         (a1-12 (+ (-> a0-38 attack-id) 1))
+                         )
+                    (set! (-> a0-38 attack-id) a1-12)
+                    (set! (-> s3-1 id) a1-12)
+                    )
+                  (set! (-> s3-1 vector quad)
+                        (-> (vector-normalize! (vector-! (new 'stack-no-clear 'vector) v1-47 (-> obj root-override2 trans)) 1.0) quad)
+                        )
+                  (set! (-> s3-1 shove-back) 24576.0)
+                  (set! (-> s3-1 shove-up) 12288.0)
+                  (set! (-> s3-1 control) (if (logtest? (focus-status board) (-> s5-2 focus-status))
+                                              1.0
+                                              0.0
+                                              )
+                        )
+                  (set! (-> s4-1 param 1) (the-as uint s3-1))
+                  )
+                (send-event-function s5-2 s4-1)
+                )
+              (let ((s2-1 (vector-x-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
+                    (s1-0 *mammoth-lightning-joint-tbl*)
+                    (s4-2 (new 'stack-no-clear 'array 'uint32 4))
+                    (s3-2 0)
+                    )
+                (let ((f30-0 (vector-dot s0-1 s2-1)))
+                  (dotimes (s0-2 (-> s1-0 length))
+                    (let* ((v0-9 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data (-> s1-0 s0-2))))
+                           (f0-12 (vector-dot (vector-! (new 'stack-no-clear 'vector) v0-9 (-> obj root-override2 trans)) s2-1))
+                           )
+                      (when (or (and (< 0.0 f0-12) (< 0.0 f30-0)) (and (< f0-12 0.0) (< f30-0 0.0)))
+                        (set! (-> s4-2 s3-2) (the-as uint (-> s1-0 s0-2)))
+                        (+! s3-2 1)
+                        (if (>= s3-2 3)
+                            (goto cfg-60)
+                            )
+                        )
+                      )
+                    )
+                  )
+                (label cfg-60)
+                (let ((s2-2 (get-process *default-dead-pool* lightning-tracker #x4000)))
+                  (when s2-2
+                    (let ((t9-11 (method-of-type lightning-tracker activate)))
+                      (t9-11
+                        (the-as lightning-tracker s2-2)
+                        s5-2
+                        (symbol->string (-> lightning-tracker symbol))
+                        (the-as pointer #x70004000)
+                        )
+                      )
+                    (let ((s5-3 run-function-in-process)
+                          (s1-1 s2-2)
+                          (s0-3 lightning-tracker-init)
+                          )
+                      (set! sv-752 (-> *lightning-spec-id-table* 1))
+                      (set! sv-768 600)
+                      (set! sv-784 (the-as symbol #f))
+                      (set! sv-800 obj)
+                      (let ((t2-0 (-> (the-as (pointer int32) (&+ s4-2 (* (get-rand-int obj s3-2) 4)))))
+                            (t3-0 6)
+                            )
+                        ((the-as (function object object object object object object object object none) s5-3)
+                         s1-1
+                         s0-3
+                         sv-752
+                         sv-768
+                         sv-784
+                         sv-800
+                         t2-0
+                         t3-0
+                         )
+                        )
+                      )
+                    (-> s2-2 ppointer)
+                    )
+                  )
+                )
+              (set! (-> obj lightning-attack-timer)
+                    (+ (-> pp clock frame-counter) (the int (* 300.0 (get-rand-float-range obj 0.067 0.1))))
+                    )
+              )
+            )
+          )
+        )
+      )
+    (mammoth-method-183 obj)
+    0
+    (none)
+    )
+  )
+
+(defmethod coin-flip? mammoth ((obj mammoth))
+  "@returns The result of a 50/50 RNG roll"
+  #f
+  )
+
+;; WARN: Return type mismatch process-focusable vs mammoth.
+(defmethod relocate mammoth ((obj mammoth) (arg0 int))
+  (dotimes (v1-0 4)
+    (if (nonzero? (-> obj joint-ik v1-0))
+        (&+! (-> obj joint-ik v1-0) arg0)
+        )
+    )
+  (the-as
+    mammoth
+    ((the-as (function process-focusable int process-focusable) (find-parent-method mammoth 7)) obj arg0)
+    )
+  )
+
+(defmethod enemy-method-114 mammoth ((obj mammoth))
+  "@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))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 11) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 12))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec enemy camera-blocker pusher))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak bot enemy player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set-vector! (-> s4-0 local-sphere) 0.0 24576.0 0.0 57344.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 enemy camera-blocker pusher))
+      (set! (-> v1-14 prim-core collide-with) (collide-spec jak bot enemy player-list))
+      (set! (-> v1-14 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set-vector! (-> v1-14 local-sphere) 0.0 24576.0 0.0 24576.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 enemy camera-blocker))
+      (set! (-> v1-16 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-16 transform-index) 3)
+      (set-vector! (-> v1-16 local-sphere) 0.0 4096.0 16384.0 16384.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 enemy camera-blocker))
+      (set! (-> v1-18 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-18 transform-index) 3)
+      (set-vector! (-> v1-18 local-sphere) 0.0 3072.0 -6144.0 16384.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 enemy camera-blocker))
+      (set! (-> v1-20 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-20 transform-index) 3)
+      (set-vector! (-> v1-20 local-sphere) 0.0 16384.0 12288.0 12288.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 enemy camera-blocker))
+      (set! (-> v1-22 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-22 transform-index) 7)
+      (set-vector! (-> v1-22 local-sphere) 0.0 0.0 0.0 8192.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 enemy camera-blocker))
+      (set! (-> v1-24 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-24 transform-index) 30)
+      (set-vector! (-> v1-24 local-sphere) 0.0 0.0 0.0 7168.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 enemy camera-blocker))
+      (set! (-> v1-26 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-26 transform-index) 31)
+      (set-vector! (-> v1-26 local-sphere) 0.0 0.0 0.0 5120.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 enemy camera-blocker))
+      (set! (-> v1-28 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-28 transform-index) 24)
+      (set-vector! (-> v1-28 local-sphere) 0.0 4096.0 0.0 6144.0)
+      )
+    (let ((v1-30 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-30 prim-core collide-as) (collide-spec enemy camera-blocker))
+      (set! (-> v1-30 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-30 transform-index) 27)
+      (set-vector! (-> v1-30 local-sphere) 0.0 -4096.0 0.0 6144.0)
+      )
+    (let ((v1-32 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-32 prim-core collide-as) (collide-spec enemy camera-blocker))
+      (set! (-> v1-32 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-32 transform-index) 9)
+      (set-vector! (-> v1-32 local-sphere) 0.0 4096.0 0.0 5734.4)
+      )
+    (let ((v1-34 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-34 prim-core collide-as) (collide-spec enemy camera-blocker))
+      (set! (-> v1-34 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-34 transform-index) 12)
+      (set-vector! (-> v1-34 local-sphere) 0.0 -4096.0 0.0 5734.4)
+      )
+    (set! (-> s5-0 nav-radius) 24576.0)
+    (let ((v1-36 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-36 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-36 prim-core collide-with))
+      )
+    (set! (-> obj root-override2) s5-0)
+    )
+  0
+  (none)
+  )
+
+(defmethod enemy-method-115 mammoth ((obj mammoth))
+  "@abstract"
+  (with-pp
+    (initialize-skeleton
+      obj
+      (the-as skeleton-group (art-group-get-by-name *level* "skel-mammoth" (the-as (pointer uint32) #f)))
+      (the-as pair 0)
+      )
+    (enemy-method-113 obj *mammoth-nav-enemy-info*)
+    (logclear! (-> obj mask) (process-mask actor-pause))
+    (set-vector! (-> obj root-override2 scale) 1.5 1.5 1.5 1.0)
+    (set! (-> obj y-level) -40959590.0)
+    (set! (-> obj foot-flags) (the-as uint 0))
+    (set! (-> obj old-foot-flags) (the-as uint 0))
+    (set! (-> obj attack-timer) (-> pp clock frame-counter))
+    (set! (-> obj spawn-timer) 0)
+    (set! (-> obj my-up-vector quad) (-> *y-vector* quad))
+    (quaternion-copy! (-> obj my-up-quat) *unity-quaternion*)
+    (set! (-> obj gspot-timer) 0)
+    (set! (-> obj gspot-normal quad) (-> *y-vector* quad))
+    (set! (-> obj align) (new 'process 'align-control obj))
+    (dotimes (s5-1 4)
+      (set! (-> obj joint-ik s5-1) (new
+                                     'process
+                                     'joint-mod-ik
+                                     obj
+                                     (-> *mammoth-ik-setup* s5-1 elbow-index)
+                                     (-> *mammoth-ik-setup* s5-1 hand-dist)
+                                     )
+            )
+      (set! (-> obj joint-ik s5-1 elbow-pole-vector-axis) (the-as uint 2))
+      (set! (-> obj joint-ik s5-1 elbow-rotation-axis) (the-as uint 0))
+      (set! (-> obj joint-ik 0 callback) mammoth-leg-ik-callback)
+      )
+    (logior! (-> obj joint-ik 1 flags) (joint-mod-ik-flags elbow-trans-neg))
+    (logior! (-> obj joint-ik 2 flags) (joint-mod-ik-flags elbow-trans-neg))
+    (logior! (-> obj joint-ik 0 flags) (joint-mod-ik-flags elbow-rot-neg))
+    (logior! (-> obj joint-ik 1 flags) (joint-mod-ik-flags elbow-rot-neg))
+    (set! (-> obj path) (new 'process 'path-control obj 'path 0.0 (-> obj entity) #f))
+    (set! (-> obj path-pos) 0.0)
+    (set! (-> obj path-index) 0)
+    (set! (-> obj path-index-dir) 1)
+    (logior! (-> obj path flags) (path-control-flag display draw-line draw-point draw-text))
+    (get-point-in-path! (-> obj path) (-> obj root-override2 trans) 0.0 'interp)
+    (set! (-> obj move-pos 0 quad) (-> obj root-override2 trans quad))
+    (set! (-> obj move-pos 1 quad) (-> obj root-override2 trans quad))
+    (forward-up-nopitch->quaternion
+      (-> obj root-override2 quat)
+      (vector-!
+        (new 'stack-no-clear 'vector)
+        (get-point-in-path! (-> obj path) (new 'stack-no-clear 'vector) (the float (+ (-> obj path-index) 1)) 'interp)
+        (-> obj root-override2 trans)
+        )
+      *up-vector*
+      )
+    (quaternion-copy! (-> obj tilt-quat) *unity-quaternion*)
+    (let ((a0-38 (-> obj node-list data 4)))
+      (set! (-> a0-38 param0) mammoth-joint-mod-tilt)
+      (set! (-> a0-38 param1) obj)
+      )
+    (let ((a0-39 (-> obj node-list data 10)))
+      (set! (-> a0-39 param0) mammoth-joint-mod-heel)
+      (set! (-> a0-39 param1) obj)
+      (set! (-> a0-39 param2) (the-as basic 0))
+      )
+    (let ((v1-61 (-> obj node-list data 13)))
+      (set! (-> v1-61 param0) mammoth-joint-mod-heel)
+      (set! (-> v1-61 param1) obj)
+      (set! (-> v1-61 param2) (the-as basic 1))
+      )
+    (let ((v1-63 (-> obj node-list data 25)))
+      (set! (-> v1-63 param0) mammoth-joint-mod-heel)
+      (set! (-> v1-63 param1) obj)
+      (set! (-> v1-63 param2) (the-as basic 2))
+      )
+    (let ((v1-65 (-> obj node-list data 28)))
+      (set! (-> v1-65 param0) mammoth-joint-mod-heel)
+      (set! (-> v1-65 param1) obj)
+      (set! (-> v1-65 param2) (the-as basic 3))
+      )
+    (dotimes (v1-66 4)
+      (set! (-> obj heel-lerp v1-66) 0.0)
+      )
+    (set! (-> obj lightning-timer) 0)
+    (set! (-> obj lightning-attack-timer) 0)
+    (set! (-> obj feet-ik-init-timer) (-> pp clock frame-counter))
+    (logclear! (-> obj enemy-flags) (enemy-flag check-water-backup))
+    0
+    (none)
+    )
+  )
diff --git a/goal_src/jak2/levels/nest/mantis.gc b/goal_src/jak2/levels/nest/mantis.gc
index f5c1ff21cf..822230eace 100644
--- a/goal_src/jak2/levels/nest/mantis.gc
+++ b/goal_src/jak2/levels/nest/mantis.gc
@@ -5,5 +5,2015 @@
 ;; name in dgo: mantis
 ;; dgos: NESTT, NES
 
+;; +++mantis:mantis-flag
+(defenum mantis-flag
+  :type uint16
+  :bitfield #t
+  (tracked 0)
+  (attack1-enabled 1)
+  )
+;; ---mantis:mantis-flag
+
 ;; DECOMP BEGINS
 
+(defpartgroup group-mantis-dust-puff
+  :id 1221
+  :duration (seconds 0.017)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 8)
+  :parts ((sp-item 5221))
+  )
+
+(defpart 5221
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 6.0)
+    (sp-rnd-flt spt-scale-x (meters 0.6) (meters 0.4) 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 8.0 1.0)
+    (sp-rnd-flt spt-g 16.0 8.0 1.0)
+    (sp-rnd-flt spt-b 16.0 8.0 1.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.01) (meters 0.0026666666) 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-r -0.35555556)
+    (sp-flt spt-fade-g -0.35555556)
+    (sp-flt spt-fade-b -0.35555556)
+    (sp-flt spt-fade-a -0.30476192)
+    (sp-flt spt-accel-y -1.3653333)
+    (sp-int spt-timer 120)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int spt-next-time 60)
+    (sp-launcher-by-id spt-next-launcher 642)
+    (sp-rnd-flt spt-conerot-x (degrees 60.0) (degrees 30.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 180.0) 1.0)
+    )
+  )
+
+(defpartgroup group-mantis-birth-nest
+  :id 1222
+  :duration (seconds 7.335)
+  :linger-duration (seconds 4)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 3 0 8)
+  :parts ((sp-item 5224 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 250 :binding 5222)
+    (sp-item 5224 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 200 :binding 5222)
+    (sp-item 5224 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 150 :binding 5222)
+    (sp-item 5224 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 100 :binding 5222)
+    (sp-item 5225 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 120 :binding 5223)
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5226 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 320)
+    )
+  )
+
+(defpart 5224
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x3 :page #xd15))
+    (sp-func spt-birth-func 'birth-func-texture-group)
+    (sp-rnd-flt spt-num 0.1 0.5 1.0)
+    (sp-rnd-flt spt-x (meters 0) (meters 1) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 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.1) 1.0)
+    (sp-rnd-flt spt-r 200.0 55.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.06666667) (meters 0.033333335) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -1.2) (degrees 2.4) 1.0)
+    (sp-rnd-flt spt-accel-y -8.192 -8.192 1.0)
+    (sp-flt spt-friction 0.98)
+    (sp-int spt-timer 350)
+    (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 -783285504 -783285248 -783284992 -783284736 -783284480)
+      )
+    (sp-func spt-func 'check-drop-level-mantis-dirt-rubble-nest)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 15.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-flt spt-conerot-radius (meters 0.1))
+    )
+  )
+
+(defpart 5223
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.0 0.2 1.0)
+    (sp-sound (static-sound-spec "debris-fall" :num 0.01 :volume 100.0))
+    (sp-rnd-flt spt-scale-x (meters 0.3) (meters 0.1) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 1) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-r 160.0 16.0 1.0)
+    (sp-rnd-flt spt-g 130.0 32.0 1.0)
+    (sp-rnd-flt spt-b 110.0 16.0 1.0)
+    (sp-rnd-flt spt-a 16.0 16.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0) (meters -0.0033333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.0033333334) (meters 0.0016666667) 1.0)
+    (sp-rnd-flt spt-scalevel-y (meters 0) (meters 0.00033333333) 1.0)
+    (sp-rnd-flt spt-fade-a -0.042666666 -0.064 1.0)
+    (sp-rnd-flt spt-accel-y -1.3653333 -1.3653333 1.0)
+    (sp-int spt-timer 250)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'check-drop-group-center)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defpart 5222
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.0 0.2 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.3) (meters 0.1) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 1) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-r 160.0 16.0 1.0)
+    (sp-rnd-flt spt-g 130.0 32.0 1.0)
+    (sp-rnd-flt spt-b 110.0 16.0 1.0)
+    (sp-rnd-flt spt-a 16.0 16.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0) (meters -0.0033333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.0033333334) (meters 0.0016666667) 1.0)
+    (sp-rnd-flt spt-scalevel-y (meters 0) (meters 0.00033333333) 1.0)
+    (sp-rnd-flt spt-fade-a -0.042666666 -0.064 1.0)
+    (sp-rnd-flt spt-accel-y -1.3653333 -1.3653333 1.0)
+    (sp-int spt-timer 750)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'check-drop-group-center)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defpart 5226
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 1.0 1.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (meters 0.5) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 1) (meters 0.5) 1.0)
+    (sp-rnd-flt spt-r 160.0 16.0 1.0)
+    (sp-rnd-flt spt-g 130.0 32.0 1.0)
+    (sp-rnd-flt spt-b 110.0 16.0 1.0)
+    (sp-rnd-flt spt-a 16.0 48.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.026666667) (meters 0.026666667) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.006666667) (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.85 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 0.0) (degrees 90.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 0.5) 1.0)
+    )
+  )
+
+(deftype mantis-jump-info (structure)
+  ((distance    float          :offset-assert   0)
+   (search-step uint32         :offset-assert   4)
+   (destination vector :inline :offset-assert  16)
+   (direction   uint16         :offset-assert  32)
+   (start-anim  uint32         :offset-assert  36)
+   (air-anim    uint32         :offset-assert  40)
+   (land-anim   uint32         :offset-assert  44)
+   )
+  :method-count-assert 9
+  :size-assert         #x30
+  :flag-assert         #x900000030
+  )
+
+
+(deftype mantis (nav-enemy)
+  ((base-height  float                    :offset-assert 604)
+   (flags        mantis-flag              :offset-assert 608)
+   (attack-timer time-frame               :offset-assert 616)
+   (track-timer  time-frame               :offset-assert 624)
+   (gspot-timer  time-frame               :offset-assert 632)
+   (gspot-normal vector           :inline :offset-assert 640)
+   (my-up-vector vector           :inline :offset-assert 656)
+   (jump         mantis-jump-info :inline :offset-assert 672)
+   )
+  :heap-base #x250
+  :method-count-assert 195
+  :size-assert         #x2d0
+  :flag-assert         #xc3025002d0
+  (:methods
+    (crawl () _type_ :state 178)
+    (attack0 () _type_ :state 179)
+    (attack1 () _type_ :state 180)
+    (ambush-crawling () _type_ :state 181)
+    (ambush-jumping () _type_ :state 182)
+    (mantis-method-183 () none 183)
+    (roll-right () _type_ :state 184)
+    (roll-left () _type_ :state 185)
+    (hop-away () _type_ :state 186)
+    (mantis-method-187 (_type_) none 187)
+    (mantis-method-188 (_type_) none 188)
+    (mantis-method-189 (_type_ vector vector) symbol 189)
+    (mantis-method-190 (_type_ vector vector) none 190)
+    (mantis-method-191 (_type_ vector vector) int 191)
+    (mantis-method-192 (_type_ vector vector) none 192)
+    (mantis-method-193 (_type_ vector) none 193)
+    (mantis-method-194 (_type_) symbol 194)
+    )
+  )
+
+
+(defskelgroup skel-mantis mantis mantis-lod0-jg mantis-idle0-ja
+              ((mantis-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 1.5 0 4)
+              :shadow mantis-shadow-mg
+              )
+
+(define *mantis-nav-enemy-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #f
+    :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 idle-control-frame 8
+      (new 'static 'idle-control-frame :command (ic-cmd push) :param0 #x1e)
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x5 :param0 #x2 :param1 #x5)
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x7 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x6 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x8 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 5
+    :notice-anim 5
+    :hostile-anim 9
+    :hit-anim 5
+    :knocked-anim 10
+    :knocked-land-anim 11
+    :die-anim 26
+    :die-falling-anim -1
+    :victory-anim 5
+    :jump-wind-up-anim -1
+    :jump-in-air-anim -1
+    :jump-land-anim -1
+    :neck-joint -1
+    :sound-hit (static-sound-name "mantis-hit")
+    :sound-die (static-sound-name "mantis-die")
+    :notice-distance (meters 50)
+    :notice-distance-delta (meters 10)
+    :proximity-notice-distance (meters 2)
+    :default-hit-points 2
+    :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
+    :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher)
+    :jump-height-min (meters 3)
+    :jump-height-factor 0.3
+    :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 106496.0
+    :knocked-red-vxz-hi 106496.0
+    :knocked-red-vy-lo 55296.0
+    :knocked-red-vy-hi 55296.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 7
+    :gem-seg #x2
+    :gem-no-seg #x4
+    :gem-offset (new 'static 'sphere :y 1286.144 :z 122.88 :r 327680.0)
+    :callback-info #f
+    :use-momentum #f
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #t
+    :use-pacing #t
+    :walk-anim 9
+    :turn-anim 5
+    :run-anim 9
+    :taunt-anim -1
+    :run-travel-speed (meters 6)
+    :run-acceleration (meters 1)
+    :run-turning-acceleration (meters 50)
+    :walk-travel-speed (meters 3)
+    :walk-acceleration (meters 1)
+    :walk-turning-acceleration (meters 20)
+    :maximum-rotation-rate (degrees 720.0)
+    :notice-nav-radius (meters 1)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 20480.0
+    :circle-dist-hi 61440.0
+    :nav-mesh #f
+    )
+  )
+
+(set! (-> *mantis-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+(defstate active (mantis)
+  :virtual #t
+  :trans (behavior ()
+    (let ((t9-1 (-> (the-as (state enemy) (find-parent-method mantis 32)) trans)))
+      (if t9-1
+          (t9-1)
+          )
+      )
+    (if (logtest? (-> self flags) (mantis-flag tracked))
+        (mantis-method-187 self)
+        )
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (until #f
+      (let ((gp-0 (get-rand-int-range self 3 5)))
+        (dotimes (s5-0 gp-0)
+          (ja-no-eval :group! mantis-idle0-ja
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-idle0-ja) frames num-frames) -1)))
+                      :frame-num 0.0
+                      )
+          (until (ja-done? 0)
+            (suspend)
+            (ja :num! (seek!))
+            )
+          )
+        )
+      (ja-no-eval :group! mantis-idle0-to-idle1-ja
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-idle0-to-idle1-ja) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      (let ((gp-1 (get-rand-int self 3)))
+        (dotimes (s5-1 gp-1)
+          (ja-no-eval :group! mantis-idle1-ja
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-idle1-ja) frames num-frames) -1)))
+                      :frame-num 0.0
+                      )
+          (until (ja-done? 0)
+            (suspend)
+            (ja :num! (seek!))
+            )
+          )
+        )
+      (ja-no-eval :group! mantis-idle1-to-idle0-ja
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-idle1-to-idle0-ja) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior mantis) nav-enemy-face-focus-post)
+  )
+
+(defstate ambush (mantis)
+  :virtual #t
+  :enter (behavior ()
+    (when (logtest? (-> self enemy-flags) (enemy-flag auto-reset-penetrate))
+      (logclear! (-> self enemy-flags) (enemy-flag auto-reset-penetrate))
+      (let ((gp-0 (-> self on-notice)))
+        (if gp-0
+            (eval!
+              (new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans))
+              (the-as pair gp-0)
+              )
+            )
+        )
+      )
+    (let ((v1-12 (-> self root-override2 root-prim)))
+      (set! (-> v1-12 prim-core collide-as) (collide-spec))
+      (set! (-> v1-12 prim-core collide-with) (collide-spec))
+      )
+    0
+    (let ((gp-1 (new 'stack-no-clear 'collide-query)))
+      (if (enemy-method-126 self gp-1 (-> self root-override2 trans) (collide-spec backgnd) 8192.0 81920.0 1024.0)
+          (set! (-> self base-height) (-> gp-1 best-other-tri intersect y))
+          (set! (-> self base-height) (-> self root-override2 trans y))
+          )
+      )
+    (let* ((gp-2 *target*)
+           (a0-5 (if (type? gp-2 process-focusable)
+                     gp-2
+                     )
+                 )
+           )
+      (when a0-5
+        (let* ((gp-3 (-> self root-override2))
+               (s3-0 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) (get-trans a0-5 0) (-> gp-3 trans)) 1.0))
+               (f0-2 (deg-diff (quaternion-y-angle (-> gp-3 quat)) (vector-y-angle s3-0)))
+               )
+          (quaternion-rotate-y! (-> gp-3 quat) (-> gp-3 quat) f0-2)
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((gp-0 (new 'stack-no-clear 'vector)))
+      (set! (-> gp-0 quad) (-> self root-override2 trans quad))
+      (set! (-> gp-0 y) (+ -18841.6 (-> 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-2 s5-0)
+                (a1-2 part-tracker-init)
+                (a2-4 (-> *part-group-id-table* 1222))
+                (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-2
+             a1-2
+             a2-4
+             a3-1
+             t0-0
+             t1-0
+             t2-0
+             t3-0
+             )
+            )
+          (-> s5-0 ppointer)
+          )
+        )
+      )
+    (let ((gp-1 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-1) (seconds 0.6))
+        (suspend)
+        )
+      )
+    (logior! (-> self draw status) (draw-control-status no-draw))
+    (let ((gp-2 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-2) (the int (* 300.0 (get-rand-float-range self 0.0 0.6))))
+        (suspend)
+        )
+      )
+    (logclear! (-> self draw status) (draw-control-status no-draw))
+    (if (rng-hit? self 0.5)
+        (go-virtual ambush-jumping)
+        (go-virtual ambush-crawling)
+        )
+    (none)
+    )
+  )
+
+(defstate ambush-crawling (mantis)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior mantis) enemy-event-handler)
+  :code (behavior ()
+    (enemy-method-109 self 1)
+    (set! (-> self root-override2 trans y) (-> self base-height))
+    (ja-channel-push! 1 0)
+    (ja-no-eval :group! mantis-ground-crawl-out-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-ground-crawl-out-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (let ((v1-28 (-> self root-override2 root-prim)))
+      (set! (-> v1-28 prim-core collide-as) (-> self root-override2 backup-collide-as))
+      (set! (-> v1-28 prim-core collide-with) (-> self root-override2 backup-collide-with))
+      )
+    (go-virtual hostile)
+    (none)
+    )
+  :post (the-as (function none :behavior mantis) nav-enemy-simple-post)
+  )
+
+(defstate ambush-jumping (mantis)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior mantis) enemy-event-handler)
+  :enter (behavior ()
+    (let ((v1-0 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-0 enemy-flags)))
+          (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-0 enemy-flags))))
+          )
+      (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-0 enemy-flags))))
+      (set! (-> v1-0 nav callback-info) (-> v1-0 enemy-info-override callback-info))
+      )
+    0
+    (let ((v1-3 self))
+      (set! (-> v1-3 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-3 enemy-flags))))
+      )
+    0
+    (enemy-method-109 self 1)
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self root-override2 trans y) (+ -18841.6 (-> self base-height)))
+    (let ((gp-0 (-> self root-override2)))
+      (let ((v1-11 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> gp-0 quat))))
+        (vector-reset! (-> gp-0 transv))
+        (set! (-> v1-11 y) 0.0)
+        )
+      (vector-reset! (-> gp-0 transv))
+      (set! (-> gp-0 transv y) (* 4096.0 (get-rand-float-range self 28.0 32.0)))
+      )
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja-no-eval :group! mantis-ground-jump-out-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-ground-jump-out-ja) frames num-frames) -1)))
+                )
+    (until #f
+      (if (< (-> self base-height) (-> self root-override2 trans y))
+          (goto cfg-5)
+          )
+      (suspend)
+      (ja :num! (seek!))
+      )
+    #f
+    (until #f
+      (label cfg-5)
+      (when (< (+ 819.2 (-> self base-height)) (-> self root-override2 trans y))
+        (let ((v1-32 (-> self root-override2 root-prim)))
+          (set! (-> v1-32 prim-core collide-as) (-> self root-override2 backup-collide-as))
+          (set! (-> v1-32 prim-core collide-with) (-> self root-override2 backup-collide-with))
+          )
+        (goto cfg-9)
+        )
+      (suspend)
+      (ja :num! (seek!))
+      )
+    #f
+    (until #f
+      (label cfg-9)
+      (if (or (and (>= (fabs (* 4096.0 (-> self clock seconds-per-frame))) (-> self root-override2 transv y))
+                   (>= (-> self base-height) (-> self root-override2 trans y))
+                   )
+              (logtest? (-> self root-override2 status) (collide-status on-ground))
+              )
+          (goto cfg-24)
+          )
+      (suspend)
+      (if (not (ja-done? 0))
+          (ja :num! (seek!))
+          )
+      )
+    #f
+    (label cfg-24)
+    (ja-channel-push! 1 (seconds 0.05))
+    (ja-no-eval :group! mantis-ground-jump-out-land-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-ground-jump-out-land-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 1))
+        (if (logtest? (-> self root-override2 status) (collide-status on-ground))
+            (goto cfg-32)
+            )
+        (suspend)
+        )
+      )
+    (label cfg-32)
+    (go-virtual hostile)
+    (none)
+    )
+  :post (the-as (function none :behavior mantis) nav-enemy-falling-post)
+  )
+
+(defstate hostile (mantis)
+  :virtual #t
+  :exit (behavior ()
+    (logclear! (-> self flags) (mantis-flag attack1-enabled))
+    (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)
+      (let ((t9-0 (-> (method-of-type nav-enemy hostile) trans)))
+        (if t9-0
+            (t9-0)
+            )
+        )
+      (let ((gp-0 (handle->process (-> self focus handle))))
+        (when gp-0
+          (let* ((s4-0 (-> self focus-pos))
+                 (s5-1 (vector-! (new 'stack-no-clear 'vector) s4-0 (-> self root-override2 trans)))
+                 )
+            (let ((s2-1 (vector-z-quaternion! (new 'stack-no-clear 'vector) (get-quat (the-as process-focusable gp-0) 0)))
+                  (s1-0 s5-1)
+                  )
+              (let ((s3-1 s5-1))
+                (let ((v1-14 (* 2.0 (vector-length (get-transv (the-as process-focusable gp-0))))))
+                  (.mov vf7 v1-14)
+                  )
+                (.lvf vf5 (&-> s2-1 quad))
+                (.lvf vf4 (&-> s3-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 (&-> s1-0 quad) vf6)
+              )
+            (let ((f30-1 (vector-length s5-1)))
+              (when (not (logtest? (-> self flags) (mantis-flag tracked)))
+                (cond
+                  ((< (- (-> self clock frame-counter) (-> self attack-timer)) (seconds 5))
+                   (if (and (< 73728.0 f30-1) (mantis-method-194 self))
+                       (go-virtual crawl)
+                       )
+                   )
+                  ((< 40960.0 f30-1)
+                   (mantis-method-190 self (the-as vector gp-0) s5-1)
+                   )
+                  )
+                )
+              (when (and (and gp-0
+                              (zero? (logand (-> (the-as process-focusable gp-0) focus-status) (focus-status disable dead ignore grabbed)))
+                              )
+                         (and (>= (- (-> self clock frame-counter) (-> self attack-timer)) (seconds 5))
+                              (enemy-method-95 self s4-0 8192.0)
+                              (< f30-1 32768.0)
+                              )
+                         )
+                (cond
+                  ((< 24576.0 f30-1)
+                   (if (logtest? (-> self flags) (mantis-flag attack1-enabled))
+                       (go-virtual attack1)
+                       )
+                   )
+                  ((< 16384.0 f30-1)
+                   (go-virtual attack0)
+                   )
+                  )
+                )
+              )
+            (if (enemy-method-95 self s4-0 10922.667)
+                (mantis-method-187 self)
+                )
+            (if (logtest? (-> self flags) (mantis-flag tracked))
+                (mantis-method-192 self (the-as vector gp-0) s5-1)
+                (mantis-method-191 self (the-as vector gp-0) s5-1)
+                )
+            )
+          )
+        )
+      (none)
+      )
+    )
+  )
+
+(defstate crawl (mantis)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior mantis) enemy-event-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (change-to (nav-mesh-from-res-tag (-> self entity) 'nav-mesh-actor 1) self)
+    (nav-enemy-method-166 self)
+    (let ((v1-6 (-> self nav)))
+      (set! (-> v1-6 max-rotation-rate) 21845.334)
+      )
+    0
+    (none)
+    )
+  :exit (behavior ()
+    (change-to (nav-mesh-from-res-tag (-> self entity) 'nav-mesh-actor 0) self)
+    (let ((v1-2 (-> self nav)))
+      (set! (-> v1-2 max-rotation-rate) (-> self enemy-info-override maximum-rotation-rate))
+      )
+    0
+    (none)
+    )
+  :trans (behavior ()
+    (nav-enemy-method-160 self)
+    (if (logtest? (-> self flags) (mantis-flag tracked))
+        (go-virtual hostile)
+        )
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (ja-channel-push! 1 (seconds 0.3))
+      (let ((v1-0 self))
+        (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logclear (-> v1-0 enemy-flags) (enemy-flag enemy-flag36))))
+        (set! (-> v1-0 nav callback-info) *nav-enemy-null-callback-info*)
+        )
+      0
+      (dotimes (gp-0 (get-rand-int-range self 1 2))
+        (ja-no-eval :group! mantis-idle0-ja
+                    :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-idle0-ja) frames num-frames) -1)))
+                    :frame-num 0.0
+                    )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek!))
+          )
+        )
+      (let ((gp-1 (handle->process (-> self focus handle))))
+        (cond
+          ((or (not gp-1) (< (the-as int (-> self focus aware)) 1))
+           (go-virtual idle)
+           )
+          (else
+            (let* ((s5-0 (-> self root-override2 trans))
+                   (s4-1 (vector-! (new 'stack-no-clear 'vector) (-> self focus-pos) s5-0))
+                   (s0-0 (vector-x-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat)))
+                   (s2-0 (new 'stack-no-clear 'vector))
+                   (s3-0 (new 'stack-no-clear 'vector))
+                   )
+              (let ((f30-1 (* 4096.0 (get-rand-float-range self 8.0 12.0)))
+                    (s1-0 (cloest-point-on-mesh (-> self nav) s5-0 s5-0 (the-as nav-poly #f)))
+                    )
+                (vector-normalize-copy! s2-0 s4-1 1.0)
+                (vector-rotate-around-y! s2-0 s2-0 (if (< 0.0 (vector-dot s2-0 s0-0))
+                                                       -16384.0
+                                                       16384.0
+                                                       )
+                                         )
+                (vector-float*! s3-0 s2-0 f30-1)
+                (clamp-vector-to-mesh-cross-gaps
+                  (-> self nav)
+                  s5-0
+                  s1-0
+                  s3-0
+                  204.8
+                  #f
+                  (the-as clamp-travel-vector-to-mesh-return-info #f)
+                  )
+                (when (< (vector-length s3-0) (+ -819.2 f30-1))
+                  (vector-float*! s3-0 s2-0 (- f30-1))
+                  (clamp-vector-to-mesh-cross-gaps
+                    (-> self nav)
+                    s5-0
+                    s1-0
+                    s3-0
+                    204.8
+                    #f
+                    (the-as clamp-travel-vector-to-mesh-return-info #f)
+                    )
+                  (if (< (vector-length s3-0) (+ -819.2 f30-1))
+                      (mantis-method-190 self (the-as vector gp-1) s4-1)
+                      )
+                  )
+                )
+              (vector+! (-> self move-dest) s5-0 s3-0)
+              )
+            (let ((a0-21 (-> self nav state))
+                  (v1-70 (-> self move-dest))
+                  )
+              (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-70 quad))
+              )
+            0
+            )
+          )
+        )
+      (ja-channel-push! 1 (seconds 0.3))
+      (let ((v1-73 self))
+        (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-73 enemy-flags)))
+            (set! (-> v1-73 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-73 enemy-flags))))
+            )
+        (set! (-> v1-73 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-73 enemy-flags))))
+        (set! (-> v1-73 nav callback-info) (-> v1-73 enemy-info-override callback-info))
+        )
+      0
+      (dotimes (gp-2 (get-rand-int-range self 3 5))
+        (ja-no-eval :group! mantis-run0-ja
+                    :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-run0-ja) frames num-frames) -1)))
+                    :frame-num 0.0
+                    )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek!))
+          )
+        (if (and (>= (- (-> self clock frame-counter) (-> self attack-timer)) (seconds 5))
+                 (< 1 (the-as int (-> self focus aware)))
+                 )
+            (go-virtual hostile)
+            )
+        (if (< (vector-vector-xz-distance (-> self root-override2 trans) (-> self move-dest)) 13107.2)
+            (goto cfg-38)
+            )
+        )
+      (label cfg-38)
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior mantis) nav-enemy-travel-post)
+  )
+
+(defstate attack0 (mantis)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior mantis) enemy-event-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (let ((v1-2 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-2 enemy-flags)))
+          (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-2 enemy-flags))))
+          )
+      (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-2 enemy-flags))))
+      (set! (-> v1-2 nav callback-info) (-> v1-2 enemy-info-override callback-info))
+      )
+    0
+    (set! (-> self attack-timer) (-> self clock frame-counter))
+    (none)
+    )
+  :exit (behavior ()
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (none)
+    )
+  :code (behavior ()
+    (logior! (-> self focus-status) (focus-status dangerous))
+    (let ((v1-2 (-> self nav)))
+      (set! (-> v1-2 target-speed) 81920.0)
+      )
+    0
+    (ja-no-eval :group! mantis-attack0-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-attack0-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (let ((v1-34 self))
+      (set! (-> v1-34 enemy-flags) (the-as enemy-flag (logclear (-> v1-34 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-34 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (ja-no-eval :group! mantis-attack0-land-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-attack0-land-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (nav-enemy-method-166 self)
+    (let ((v1-63 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-63 enemy-flags)))
+          (set! (-> v1-63 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-63 enemy-flags))))
+          )
+      (set! (-> v1-63 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-63 enemy-flags))))
+      (set! (-> v1-63 nav callback-info) (-> v1-63 enemy-info-override callback-info))
+      )
+    0
+    (go-hostile self)
+    (none)
+    )
+  :post (the-as (function none :behavior mantis) nav-enemy-chase-post)
+  )
+
+(defstate attack1 (mantis)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior mantis) enemy-event-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self attack-timer) (-> self clock frame-counter))
+    (none)
+    )
+  :exit (behavior ()
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (none)
+    )
+  :code (behavior ()
+    (let ((v1-0 self))
+      (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logclear (-> v1-0 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-0 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (ja-no-eval :group! mantis-attack1-wind-up-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-attack1-wind-up-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (let ((a0-5 (handle->process (-> self focus handle))))
+        (if a0-5
+            (seek-to-point-toward-point!
+              (-> self root-override2)
+              (get-trans (the-as process-focusable a0-5) 0)
+              (-> self nav max-rotation-rate)
+              (seconds 0.02)
+              )
+            )
+        )
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (let ((v1-36 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-36 enemy-flags)))
+          (set! (-> v1-36 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-36 enemy-flags))))
+          )
+      (set! (-> v1-36 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-36 enemy-flags))))
+      (set! (-> v1-36 nav callback-info) (-> v1-36 enemy-info-override callback-info))
+      )
+    0
+    (logior! (-> self focus-status) (focus-status dangerous))
+    (let ((v1-41 (-> self nav)))
+      (set! (-> v1-41 target-speed) 286720.0)
+      )
+    0
+    (ja-no-eval :group! mantis-attack1-go-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-attack1-go-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (let ((v1-73 self))
+      (set! (-> v1-73 enemy-flags) (the-as enemy-flag (logclear (-> v1-73 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-73 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (ja-no-eval :group! mantis-attack1-land-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-attack1-land-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (nav-enemy-method-166 self)
+    (let ((v1-102 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-102 enemy-flags)))
+          (set! (-> v1-102 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-102 enemy-flags))))
+          )
+      (set! (-> v1-102 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-102 enemy-flags))))
+      (set! (-> v1-102 nav callback-info) (-> v1-102 enemy-info-override callback-info))
+      )
+    0
+    (go-hostile self)
+    (none)
+    )
+  :post (the-as (function none :behavior mantis) nav-enemy-chase-post)
+  )
+
+(defstate roll-right (mantis)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior mantis) 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) 0.0)
+    (vector-normalize! (-> self root-override2 transv) -88064.0)
+    (let ((v1-6 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-6 enemy-flags)))
+          (set! (-> v1-6 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-6 enemy-flags))))
+          )
+      (set! (-> v1-6 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-6 enemy-flags))))
+      (set! (-> v1-6 nav callback-info) (-> v1-6 enemy-info-override callback-info))
+      )
+    0
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja-no-eval :group! mantis-roll-right-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-roll-right-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (let ((v1-33 self))
+      (set! (-> v1-33 enemy-flags) (the-as enemy-flag (logclear (-> v1-33 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-33 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (ja-no-eval :group! mantis-roll-right-land-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-roll-right-land-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (logior! (-> self flags) (mantis-flag attack1-enabled))
+    (go-hostile self)
+    (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 (mantis)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior mantis) 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) 27443.2)
+    (vector-xz-normalize! (-> self root-override2 transv) 102400.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.067))
+    (ja-no-eval :group! mantis-hop-left-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-hop-left-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (let ((v1-34 self))
+      (set! (-> v1-34 enemy-flags) (the-as enemy-flag (logclear (-> v1-34 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-34 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (ja-no-eval :group! mantis-hop-left-land-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-hop-left-land-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (go-hostile self)
+    (none)
+    )
+  :post (-> (method-of-type mantis roll-right) post)
+  )
+
+(defstate hop-away (mantis)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior mantis) enemy-event-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (enemy-method-109 self 1)
+    (logior! (-> self enemy-flags) (enemy-flag use-notice-distance))
+    (let ((v1-6 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-6 enemy-flags)))
+          (set! (-> v1-6 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-6 enemy-flags))))
+          )
+      (set! (-> v1-6 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-6 enemy-flags))))
+      (set! (-> v1-6 nav callback-info) (-> v1-6 enemy-info-override callback-info))
+      )
+    0
+    (nav-enemy-method-165 self)
+    (let ((v1-11 self))
+      (set! (-> v1-11 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-11 enemy-flags))))
+      )
+    0
+    (logclear! (-> self mask) (process-mask actor-pause))
+    (set! (-> self starting-time) (the-as uint (-> self clock frame-counter)))
+    (none)
+    )
+  :trans (behavior ()
+    '()
+    (none)
+    )
+  :code (behavior ()
+    (rlet ((acc :class vf)
+           (vf0 :class vf)
+           (vf4 :class vf)
+           (vf5 :class vf)
+           (vf6 :class vf)
+           (vf7 :class vf)
+           )
+      (init-vf0-vector)
+      (ja-channel-push! 1 (seconds 0.2))
+      (until #f
+        (let ((gp-0 (handle->process (-> self focus handle))))
+          (when gp-0
+            (let* ((v1-5 (-> self focus-pos))
+                   (s5-1 (vector-! (new 'stack-no-clear 'vector) v1-5 (-> self root-override2 trans)))
+                   )
+              (let ((s4-1 (vector-z-quaternion! (new 'stack-no-clear 'vector) (get-quat (the-as process-focusable gp-0) 0))))
+                (if (and (>= (vector-length s5-1) 122880.0) (mantis-method-194 self))
+                    (go-virtual crawl)
+                    )
+                (let ((s2-0 s5-1))
+                  (let ((s3-1 s5-1))
+                    (let ((v1-21 (* 0.2 (vector-length (get-transv (the-as process-focusable gp-0))))))
+                      (.mov vf7 v1-21)
+                      )
+                    (.lvf vf5 (&-> s4-1 quad))
+                    (.lvf vf4 (&-> s3-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 (&-> s2-0 quad) vf6)
+                  )
+                )
+              (if (not (or (mantis-method-191 self (the-as vector gp-0) s5-1) (not (mantis-method-194 self))))
+                  (go-virtual crawl)
+                  )
+              )
+            (if (and (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+                     (>= (the-as int (-> self focus aware)) 3)
+                     (enemy-method-107 self)
+                     )
+                (go-hostile self)
+                )
+            )
+          )
+        (dotimes (gp-1 (get-rand-int-range self 2 4))
+          (ja-no-eval :group! mantis-idle0-ja
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-idle0-ja) frames num-frames) -1)))
+                      :frame-num 0.0
+                      )
+          (until (ja-done? 0)
+            (suspend)
+            (ja :num! (seek!))
+            )
+          )
+        )
+      #f
+      (none)
+      )
+    )
+  :post (the-as (function none :behavior mantis) nav-enemy-face-focus-post)
+  )
+
+(defmethod enemy-method-74 mantis ((obj mantis) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (with-pp
+    (case arg2
+      (('track)
+       (if (and (-> arg3 param 0) (>= (- (-> pp clock frame-counter) (-> obj track-timer)) (seconds 0.5)))
+           'abort
+           #t
+           )
+       )
+      (('tracked)
+       (logior! (-> obj flags) (mantis-flag tracked))
+       (let ((v0-0 (the-as object (-> pp clock frame-counter))))
+         (set! (-> obj track-timer) (the-as time-frame v0-0))
+         v0-0
+         )
+       )
+      (('hit 'hit-knocked)
+       (logclear! (-> obj mask) (process-mask actor-pause))
+       (logclear! (-> obj focus-status) (focus-status dangerous))
+       (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice))
+       (logior! (-> obj enemy-flags) (enemy-flag chase-startup))
+       (logior! (-> obj focus-status) (focus-status hit))
+       (if (zero? (-> obj hit-points))
+           (logior! (-> obj focus-status) (focus-status dead))
+           )
+       (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup))
+       (enemy-method-62 obj)
+       (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
+       (process-contact-action arg0)
+       (send-event arg0 'get-attack-count 1)
+       (cond
+         ((zero? (-> obj hit-points))
+          (let ((s5-1 (-> obj incoming knocked-type)))
+            (cond
+              ((and (= s5-1 (knocked-type knocked-type-4))
+                    (not (and (-> obj next-state) (let ((v1-41 (-> obj next-state name)))
+                                                    (or (= v1-41 'knocked) (= v1-41 'jump) (= v1-41 'jump-land))
+                                                    )
+                              )
+                         )
+                    (zero? (get-rand-int obj 3))
+                    (let ((f0-0 (vector-vector-distance-squared (-> obj root-override2 trans) (target-pos 0)))
+                          (f1-0 32768.0)
+                          )
+                      (>= f0-0 (* f1-0 f1-0))
+                      )
+                    )
+               (enemy-method-73 obj)
+               )
+              ((or (= s5-1 (knocked-type knocked-type-4)) (= s5-1 (knocked-type knocked-type-6)))
+               (set! (-> obj incoming knocked-type) (knocked-type knocked-type-0))
+               (go (method-of-object obj knocked))
+               )
+              (else
+                (go (method-of-object obj knocked))
+                )
+              )
+            )
+          )
+         (else
+           (go (method-of-object obj knocked))
+           )
+         )
+       #t
+       )
+      (else
+        ((method-of-type nav-enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+        )
+      )
+    )
+  )
+
+(defmethod enemy-method-77 mantis ((obj mantis) (arg0 (pointer float)))
+  (case (-> obj incoming knocked-type)
+    (((knocked-type knocked-type-6))
+     (ja-channel-push! 1 (seconds 0.02))
+     (let ((a0-3 (-> obj skel root-channel 0)))
+       (set! (-> a0-3 frame-group) (the-as art-joint-anim (-> obj draw art-group data 27)))
+       (set! (-> a0-3 param 0)
+             (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 27)) frames num-frames) -1))
+             )
+       (set! (-> a0-3 param 1) (-> arg0 0))
+       (set! (-> a0-3 frame-num) 0.0)
+       (joint-control-channel-group! a0-3 (the-as art-joint-anim (-> obj draw art-group data 27)) num-func-seek!)
+       )
+     #t
+     )
+    (else
+      (ja-channel-push! 1 (seconds 0.2))
+      (let ((a0-5 (-> obj skel root-channel 0)))
+        (set! (-> a0-5 frame-group) (the-as art-joint-anim (-> obj draw art-group data 10)))
+        (set! (-> a0-5 param 0)
+              (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 10)) 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 (-> obj draw art-group data 10)) num-func-seek!)
+        )
+      #t
+      )
+    )
+  )
+
+(defmethod enemy-method-78 mantis ((obj mantis) (arg0 (pointer float)))
+  (cond
+    ((zero? (-> obj hit-points))
+     (ja-channel-push! 1 (seconds 0.1))
+     (let ((a0-2 (-> obj skel root-channel 0)))
+       (set! (-> a0-2 frame-group) (the-as art-joint-anim (-> obj draw art-group data 26)))
+       (set! (-> a0-2 param 0)
+             (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 26)) frames num-frames) -1))
+             )
+       (set! (-> a0-2 param 1) (-> arg0 0))
+       (set! (-> a0-2 frame-num) 0.0)
+       (joint-control-channel-group! a0-2 (the-as art-joint-anim (-> obj draw art-group data 26)) num-func-seek!)
+       )
+     #t
+     )
+    ((let ((v1-15 (-> obj incoming knocked-type)))
+       (= v1-15 (knocked-type knocked-type-6))
+       )
+     (let ((a0-4 (-> obj skel root-channel 0)))
+       (set! (-> a0-4 frame-group) (the-as art-joint-anim (-> obj draw art-group data 28)))
+       (set! (-> a0-4 param 0)
+             (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 28)) 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 (-> obj draw art-group data 28)) num-func-seek!)
+       )
+     #t
+     )
+    (else
+      (ja-channel-push! 1 (seconds 0.1))
+      (let ((a0-6 (-> obj skel root-channel 0)))
+        (set! (-> a0-6 frame-group) (the-as art-joint-anim (-> obj draw art-group data 11)))
+        (set! (-> a0-6 param 0)
+              (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 11)) frames num-frames) -1))
+              )
+        (set! (-> a0-6 param 1) (-> arg0 0))
+        (set! (-> a0-6 frame-num) 0.0)
+        (joint-control-channel-group! a0-6 (the-as art-joint-anim (-> obj draw art-group data 11)) num-func-seek!)
+        )
+      #t
+      )
+    )
+  )
+
+;; WARN: Return type mismatch symbol vs pat-surface.
+(defmethod enemy-method-125 mantis ((obj mantis) (arg0 collide-query) (arg1 collide-spec) (arg2 float) (arg3 float) (arg4 float))
+  (with-pp
+    (the-as
+      pat-surface
+      (when (find-ground (-> obj root-override2) arg0 arg1 arg2 arg3 arg4)
+        (set! (-> obj root-override2 ground-pat) (-> arg0 best-other-tri pat))
+        (when (>= (- (-> pp clock frame-counter) (-> obj gspot-timer)) (seconds 0.2))
+          (let ((a1-2 (new 'stack-no-clear 'collide-query)))
+            (set! (-> a1-2 start-pos quad) (-> obj root-override2 gspot-pos quad))
+            (set! (-> a1-2 start-pos y) (+ 2048.0 (-> a1-2 start-pos y)))
+            (set-vector! (-> a1-2 move-dist) 0.0 -6144.0 0.0 0.0)
+            (let ((v1-10 a1-2))
+              (set! (-> v1-10 radius) 4915.2)
+              (set! (-> v1-10 collide-with) arg1)
+              (set! (-> v1-10 ignore-process0) obj)
+              (set! (-> v1-10 ignore-process1) #f)
+              (set! (-> v1-10 ignore-pat) (-> obj root-override2 pat-ignore-mask))
+              (set! (-> v1-10 action-mask) (collide-action solid))
+              )
+            (fill-using-line-sphere *collide-cache* a1-2)
+            )
+          (let ((s5-1 (new 'stack-no-clear 'vector)))
+            (vector-reset! s5-1)
+            (dotimes (s4-1 (-> *collide-cache* num-tris))
+              (let* ((v1-16 (-> *collide-cache* tris s4-1))
+                     (s2-1 (vector-! (new 'stack-no-clear 'vector) (-> v1-16 vertex 1) (the-as vector (-> v1-16 vertex))))
+                     (s1-1 (vector-! (new 'stack-no-clear 'vector) (-> v1-16 vertex 2) (the-as vector (-> v1-16 vertex))))
+                     (s3-0 (new 'stack-no-clear 'vector))
+                     )
+                (vector-normalize! s2-1 1.0)
+                (vector-normalize! s1-1 1.0)
+                (vector-cross! s3-0 s2-1 s1-1)
+                (if (< (cos 10922.667) (vector-dot s3-0 *y-vector*))
+                    (vector+! s5-1 s5-1 s3-0)
+                    )
+                )
+              )
+            (vector-normalize-copy! (-> obj gspot-normal) s5-1 1.0)
+            )
+          (set! (-> obj gspot-timer) (-> pp clock frame-counter))
+          )
+        #t
+        )
+      )
+    )
+  )
+
+;; WARN: Return type mismatch object vs symbol.
+(defmethod mantis-method-194 mantis ((obj mantis))
+  (let ((a0-2 (nav-mesh-from-res-tag (-> obj entity) 'nav-mesh-actor 1))
+        (gp-0 (new 'stack-no-clear 'vector))
+        )
+    (the-as symbol (and a0-2
+                        (nav-mesh-method-10 a0-2 gp-0 (-> obj root-override2 trans) (the-as nav-poly #f))
+                        (< (vector-vector-xz-distance gp-0 (-> obj root-override2 trans)) 2048.0)
+                        )
+            )
+    )
+  )
+
+(defmethod mantis-method-193 mantis ((obj mantis) (arg0 vector))
+  (with-pp
+    (cond
+      ((= (-> obj root-override2 gspot-pos y) -40959590.0)
+       (set! (-> arg0 y) 0.0)
+       (vector-normalize! arg0 1.0)
+       (quaternion-set! (-> obj root-override2 quat) 0.0 (-> arg0 x) 0.0 (+ 1.0 (-> arg0 z)))
+       (quaternion-normalize! (-> obj root-override2 quat))
+       )
+      (else
+        (let ((s4-0 (new 'stack-no-clear 'vector)))
+          (set! (-> s4-0 quad) (-> *up-vector* quad))
+          (let ((s3-0 (new 'stack-no-clear 'quaternion)))
+            (quaternion-from-two-vectors-max-angle! s3-0 s4-0 (-> obj gspot-normal) 10922.667)
+            (vector-orient-by-quat! s4-0 s4-0 s3-0)
+            )
+          (let ((s3-1 (-> obj my-up-vector)))
+            (vector-deg-seek s3-1 s3-1 s4-0 (* 8192.0 (-> pp clock seconds-per-frame)))
+            (vector-normalize! s3-1 1.0)
+            (set! (-> arg0 y) 0.0)
+            (vector-normalize! arg0 1.0)
+            (forward-up-nopitch->quaternion (-> obj root-override2 quat) arg0 s3-1)
+            )
+          )
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+(defmethod nav-enemy-method-142 mantis ((obj mantis) (arg0 nav-control))
+  (let ((t9-0 (method-of-object obj mantis-method-193))
+        (a2-0 (-> arg0 state))
+        (a1-1 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> a1-1 quad) (-> a2-0 heading quad))
+    (t9-0 obj a1-1)
+    )
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch vector vs none.
+(defmethod enemy-method-55 mantis ((obj mantis))
+  (local-vars (s5-0 vector))
+  (let ((t9-0 (method-of-type nav-enemy enemy-method-55)))
+    (t9-0 obj)
+    )
+  (logclear! (-> obj flags) (mantis-flag tracked))
+  (let ((a0-4 (handle->process (-> obj focus handle))))
+    (set! s5-0 (when a0-4
+                 (set! s5-0 (-> obj focus-pos))
+                 (set! (-> s5-0 quad) (-> (get-trans (the-as process-focusable a0-4) 0) quad))
+                 s5-0
+                 )
+          )
+    )
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod mantis-method-187 mantis ((obj mantis))
+  (let ((s3-0 (vector-x-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
+        (s4-0 (-> obj root-override2))
+        (s5-0 (lambda ((arg0 mantis) (arg1 collide-shape-moving) (arg2 vector))
+                (let ((s3-0 (new 'stack-no-clear 'vector))
+                      (f30-0 (vector-length arg2))
+                      )
+                  (clamp-vector-to-mesh-cross-gaps
+                    (-> arg0 nav)
+                    (-> arg1 trans)
+                    (-> arg0 nav state current-poly)
+                    arg2
+                    204.8
+                    #f
+                    (the-as clamp-travel-vector-to-mesh-return-info #f)
+                    )
+                  (vector+! s3-0 (-> arg1 trans) arg2)
+                  (cond
+                    ((< (vector-vector-xz-distance (-> arg1 trans) s3-0) (+ -8192.0 f30-0))
+                     #f
+                     )
+                    ((let ((a1-5 (new 'stack-no-clear 'vector)))
+                       (set! (-> a1-5 quad) (-> s3-0 quad))
+                       (set! (-> a1-5 w) (-> arg0 root-override2 nav-radius))
+                       (add-root-sphere-to-hash! (-> arg0 nav) a1-5 1134)
+                       )
+                     #f
+                     )
+                    (else
+                      (let ((a1-6 (new 'stack-no-clear 'collide-query)))
+                        (set! (-> a1-6 start-pos quad) (-> arg1 trans quad))
+                        (set! (-> a1-6 move-dist quad) (-> arg2 quad))
+                        (let ((v1-14 a1-6))
+                          (set! (-> v1-14 radius) 2048.0)
+                          (set! (-> v1-14 collide-with) (-> arg1 root-prim prim-core collide-with))
+                          (set! (-> v1-14 ignore-process0) arg0)
+                          (set! (-> v1-14 ignore-process1) #f)
+                          (set! (-> v1-14 ignore-pat) (-> arg1 pat-ignore-mask))
+                          (set! (-> v1-14 action-mask) (collide-action solid))
+                          )
+                        (if (>= (fill-and-probe-using-line-sphere *collide-cache* a1-6) 0.0)
+                            #f
+                            #t
+                            )
+                        )
+                      )
+                    )
+                  )
+                )
+              )
+        )
+    (cond
+      ((s5-0 obj s4-0 (vector-normalize-copy! (new 'stack-no-clear 'vector) s3-0 -40960.0))
+       (go (method-of-object obj roll-right))
+       )
+      ((s5-0 obj s4-0 (vector-normalize-copy! (new 'stack-no-clear 'vector) s3-0 34160.64))
+       (go (method-of-object obj roll-left))
+       )
+      )
+    )
+  (none)
+  )
+
+(defmethod mantis-method-188 mantis ((obj mantis))
+  (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
+        (let* ((v1-4 (-> obj focus-pos))
+               (s4-1 (vector-! (new 'stack-no-clear 'vector) v1-4 (-> obj root-override2 trans)))
+               )
+          (let ((s2-1 (vector-z-quaternion! (new 'stack-no-clear 'vector) (get-quat (the-as process-focusable s5-0) 0)))
+                (s1-0 s4-1)
+                )
+            (let ((s3-1 s4-1))
+              (let ((v1-10 (* 0.2 (vector-length (get-transv (the-as process-focusable s5-0))))))
+                (.mov vf7 v1-10)
+                )
+              (.lvf vf5 (&-> s2-1 quad))
+              (.lvf vf4 (&-> s3-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 (&-> s1-0 quad) vf6)
+            )
+          (mantis-method-191 obj (the-as vector s5-0) s4-1)
+          )
+        )
+      )
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod go-stare mantis ((obj mantis))
+  (let ((a0-2 (handle->process (-> obj focus handle))))
+    (if (and a0-2
+             (and (< 81920.0
+                     (vector-vector-xz-distance (-> obj root-override2 trans) (get-trans (the-as process-focusable a0-2) 0))
+                     )
+                  (mantis-method-194 obj)
+                  )
+             )
+        (go (method-of-object obj crawl))
+        )
+    )
+  (go (method-of-object obj hop-away))
+  (none)
+  )
+
+(defmethod mantis-method-190 mantis ((obj mantis) (arg0 vector) (arg1 vector))
+  (let ((s5-0 (-> obj jump)))
+    (let* ((f0-0 (vector-length arg1))
+           (f0-1 (if (< 102400.0 f0-0)
+                     81920.0
+                     (+ -20480.0 f0-0)
+                     )
+                 )
+           )
+      (vector-normalize! arg1 f0-1)
+      )
+    (when (mantis-method-189 obj (-> s5-0 destination) arg1)
+      (set! (-> s5-0 direction) (the-as uint 0))
+      (set! (-> s5-0 start-anim) (the-as uint 12))
+      (set! (-> s5-0 air-anim) (the-as uint 13))
+      (set! (-> s5-0 land-anim) (the-as uint 0))
+      (set! (-> obj enemy-flags) (the-as enemy-flag (logclear (-> obj enemy-flags) (enemy-flag vulnerable))))
+      (send-event obj 'jump 0 (-> s5-0 destination))
+      )
+    )
+  0
+  (none)
+  )
+
+(defmethod mantis-method-191 mantis ((obj mantis) (arg0 vector) (arg1 vector))
+  (let ((s5-0 (-> obj jump)))
+    (vector-length arg1)
+    (vector-normalize! arg1 1.0)
+    (vector-rotate-y! arg1 arg1 (* 182.04445 (get-rand-float-range obj -45.0 45.0)))
+    (let ((a2-5
+            (vector-normalize-copy! (new 'stack-no-clear 'vector) arg1 (* 4096.0 (get-rand-float-range obj -4.0 -6.0)))
+            )
+          )
+      (when (mantis-method-189 obj (-> s5-0 destination) a2-5)
+        (set! (-> s5-0 direction) (the-as uint 1))
+        (set! (-> s5-0 start-anim) (the-as uint 14))
+        (set! (-> s5-0 air-anim) (the-as uint 15))
+        (set! (-> s5-0 land-anim) (the-as uint 16))
+        (set! (-> obj enemy-flags) (the-as enemy-flag (logclear (-> obj enemy-flags) (enemy-flag vulnerable))))
+        (send-event obj 'jump 0 (-> s5-0 destination))
+        )
+      )
+    )
+  0
+  )
+
+(defmethod mantis-method-192 mantis ((obj mantis) (arg0 vector) (arg1 vector))
+  (let ((s5-0 (-> obj jump)))
+    (vector-length arg1)
+    (vector-normalize! arg1 1.0)
+    (vector-rotate-y! arg1 arg1 (* 182.04445 (get-rand-float-range obj -45.0 45.0)))
+    (let ((a2-5
+            (vector-normalize-copy! (new 'stack-no-clear 'vector) arg1 (* 4096.0 (get-rand-float-range obj -15.0 -22.0)))
+            )
+          )
+      (when (mantis-method-189 obj (-> s5-0 destination) a2-5)
+        (set! (-> s5-0 direction) (the-as uint 1))
+        (set! (-> s5-0 start-anim) (the-as uint 20))
+        (set! (-> s5-0 air-anim) (the-as uint 21))
+        (set! (-> s5-0 land-anim) (the-as uint 22))
+        (set! (-> obj enemy-flags) (the-as enemy-flag (logclear (-> obj enemy-flags) (enemy-flag vulnerable))))
+        (send-event obj 'jump 0 (-> s5-0 destination))
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+(defmethod mantis-method-189 mantis ((obj mantis) (arg0 vector) (arg1 vector))
+  (let* ((s4-0 (vector-normalize-copy! (new 'stack-no-clear 'vector) arg1 1.0))
+         (f30-0 (vector-length arg1))
+         (f28-0 3640.889)
+         (f26-0 f28-0)
+         (s3-1
+           (lambda ((arg0 mantis) (arg1 vector) (arg2 float) (arg3 float) (arg4 vector))
+             (local-vars (v0-3 vector))
+             (let* ((s3-0 (-> arg0 root-override2 trans))
+                    (a0-2 (vector-rotate-y! (new 'stack-no-clear 'vector) arg1 arg3))
+                    (s5-1 (vector+float*! (new 'stack-no-clear 'vector) s3-0 a0-2 arg2))
+                    (s2-0 (new 'stack-no-clear 'vector))
+                    )
+               (cloest-point-on-mesh (-> arg0 nav) s5-1 s5-1 (the-as nav-poly #f))
+               (vector-! s2-0 s5-1 s3-0)
+               (clamp-vector-to-mesh-cross-gaps
+                 (-> arg0 nav)
+                 s3-0
+                 (-> arg0 nav state current-poly)
+                 s2-0
+                 204.8
+                 #f
+                 (the-as clamp-travel-vector-to-mesh-return-info #f)
+                 )
+               (when (< 0.8 (/ (vector-length s2-0) arg2))
+                 (vector+! s5-1 s3-0 s2-0)
+                 (let ((a1-7 (new 'stack-no-clear 'collide-query)))
+                   (set! (-> a1-7 start-pos quad) (-> s3-0 quad))
+                   (set! (-> a1-7 move-dist quad) (-> s2-0 quad))
+                   (+! (-> a1-7 start-pos y) (* 1.5 (-> arg0 enemy-info-override jump-height-min)))
+                   (let ((v1-17 a1-7))
+                     (set! (-> v1-17 radius) 409.6)
+                     (set! (-> v1-17 collide-with) (collide-spec backgnd))
+                     (set! (-> v1-17 ignore-process0) #f)
+                     (set! (-> v1-17 ignore-process1) #f)
+                     (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))
+                     )
+                   (when (< (fill-and-probe-using-line-sphere *collide-cache* a1-7) 0.0)
+                     (set! (-> s5-1 w) (-> arg0 root-override2 nav-radius))
+                     (when (not (add-root-sphere-to-hash! (-> arg0 nav) s5-1 #x8046e))
+                       (set! (-> arg4 quad) (-> s5-1 quad))
+                       (return arg4)
+                       v0-3
+                       )
+                     )
+                   )
+                 )
+               )
+             )
+           )
+         )
+    (cond
+      ((s3-1 obj s4-0 f30-0 0.0 arg0)
+       #t
+       )
+      (else
+        (dotimes (s2-0 2)
+          (if (or (s3-1 obj s4-0 f30-0 f26-0 arg0) (s3-1 obj s4-0 f30-0 (- f26-0) arg0))
+              (return #t)
+              )
+          (+! f26-0 f28-0)
+          )
+        #f
+        )
+      )
+    )
+  )
+
+(defmethod enemy-method-89 mantis ((obj mantis) (arg0 enemy-jump-info))
+  (ja-channel-push! 1 (seconds 0.1))
+  (let ((a1-2 (-> obj draw art-group data (-> obj jump start-anim)))
+        (a0-4 (-> obj skel root-channel 0))
+        )
+    (set! (-> a0-4 frame-group) (the-as art-joint-anim a1-2))
+    (set! (-> a0-4 param 0) (the float (+ (-> (the-as art-joint-anim a1-2) frames num-frames) -1)))
+    (set! (-> a0-4 param 1) (-> arg0 anim-speed))
+    (set! (-> a0-4 frame-num) 0.0)
+    (joint-control-channel-group! a0-4 (the-as art-joint-anim a1-2) num-func-seek!)
+    )
+  #t
+  )
+
+(defmethod enemy-method-87 mantis ((obj mantis) (arg0 enemy-jump-info))
+  (ja-channel-push! 1 (seconds 0.1))
+  (let ((a1-2 (-> obj draw art-group data (-> obj jump air-anim)))
+        (a0-4 (-> obj skel root-channel 0))
+        )
+    (set! (-> a0-4 frame-group) (the-as art-joint-anim a1-2))
+    (set! (-> a0-4 param 0) (the float (+ (-> (the-as art-joint-anim a1-2) frames num-frames) -1)))
+    (set! (-> a0-4 param 1) (-> arg0 anim-speed))
+    (set! (-> a0-4 frame-num) 0.0)
+    (joint-control-channel-group! a0-4 (the-as art-joint-anim a1-2) num-func-seek!)
+    )
+  #t
+  )
+
+;; WARN: Return type mismatch quaternion vs none.
+(defmethod enemy-method-92 mantis ((obj mantis) (arg0 int) (arg1 nav-poly))
+  "TODO - nav-poly is a guess
+@abstract"
+  (let ((v1-0 arg0))
+    (when (or (zero? v1-0) (= v1-0 1) (= v1-0 2) (= v1-0 3))
+      (let ((a0-4 obj))
+        (when (logtest? (enemy-flag enemy-flag37) (-> a0-4 enemy-flags))
+          (let ((s5-1 (vector-! (new 'stack-no-clear 'vector) (-> arg1 vertex2) (-> obj root-override2 trans))))
+            (vector-normalize! s5-1 1.0)
+            (let ((v1-5 (-> obj jump direction)))
+              (cond
+                ((zero? v1-5)
+                 )
+                ((= v1-5 1)
+                 (vector-negate! s5-1 s5-1)
+                 )
+                ((= v1-5 2)
+                 (vector-rotate-y! s5-1 s5-1 -16384.0)
+                 )
+                ((= v1-5 3)
+                 (vector-rotate-y! s5-1 s5-1 16384.0)
+                 )
+                )
+              )
+            (seek-toward-heading-vec! (-> obj root-override2) s5-1 (-> obj nav max-rotation-rate) (seconds 0.02))
+            )
+          )
+        )
+      )
+    )
+  (none)
+  )
+
+(defmethod enemy-method-88 mantis ((obj mantis) (arg0 enemy-jump-info))
+  (cond
+    ((zero? (-> obj jump land-anim))
+     #f
+     )
+    (else
+      (ja-channel-push! 1 (seconds 0.075))
+      (let ((a1-2 (-> obj draw art-group data (-> obj jump land-anim)))
+            (a0-4 (-> obj skel root-channel 0))
+            )
+        (set! (-> a0-4 frame-group) (the-as art-joint-anim a1-2))
+        (set! (-> a0-4 param 0) (the float (+ (-> (the-as art-joint-anim a1-2) frames num-frames) -1)))
+        (set! (-> a0-4 param 1) (-> arg0 anim-speed))
+        (set! (-> a0-4 frame-num) 0.0)
+        (joint-control-channel-group! a0-4 (the-as art-joint-anim a1-2) num-func-seek!)
+        )
+      #t
+      )
+    )
+  )
+
+(defmethod coin-flip? mantis ((obj mantis))
+  "@returns The result of a 50/50 RNG roll"
+  #f
+  )
+
+;; WARN: Return type mismatch collide-shape-moving vs none.
+(defmethod enemy-method-114 mantis ((obj mantis))
+  "@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 8) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 9))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec enemy))
+      (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 can-ride deadly no-standon))
+      (set-vector! (-> s4-0 local-sphere) 0.0 6144.0 0.0 17408.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 crate obstacle hit-by-others-list player-list)
+            )
+      (set! (-> v1-13 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set-vector! (-> v1-13 local-sphere) 0.0 4915.2 0.0 4915.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 enemy))
+      (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) 7)
+      (set-vector! (-> v1-15 local-sphere) 0.0 0.0 0.0 2048.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 player-list))
+      (set! (-> v1-17 prim-core action) (collide-action solid))
+      (set! (-> v1-17 transform-index) 13)
+      (set-vector! (-> v1-17 local-sphere) 0.0 0.0 0.0 2048.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 player-list))
+      (set! (-> v1-19 prim-core action) (collide-action solid))
+      (set! (-> v1-19 transform-index) 10)
+      (set-vector! (-> v1-19 local-sphere) 0.0 0.0 0.0 2048.0)
+      )
+    (let ((v1-21 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-21 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-21 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-21 prim-core action) (collide-action solid deadly))
+      (set! (-> v1-21 transform-index) 24)
+      (set-vector! (-> v1-21 local-sphere) 0.0 0.0 0.0 2457.6)
+      )
+    (let ((v1-23 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-23 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-23 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-23 prim-core action) (collide-action solid deadly))
+      (set! (-> v1-23 transform-index) 19)
+      (set-vector! (-> v1-23 local-sphere) 0.0 0.0 0.0 2457.6)
+      )
+    (let ((v1-25 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-25 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-25 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-25 prim-core action) (collide-action solid deadly))
+      (set! (-> v1-25 transform-index) 27)
+      (set-vector! (-> v1-25 local-sphere) 0.0 0.0 0.0 1228.8)
+      )
+    (let ((v1-27 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-27 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-27 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-27 prim-core action) (collide-action solid deadly))
+      (set! (-> v1-27 transform-index) 28)
+      (set-vector! (-> v1-27 local-sphere) 0.0 0.0 0.0 2048.0)
+      )
+    (set! (-> s5-0 nav-radius) 8192.0)
+    (let ((v1-29 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-29 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-29 prim-core collide-with))
+      )
+    (set! (-> obj root-override2) s5-0)
+    )
+  (none)
+  )
+
+(defmethod enemy-method-115 mantis ((obj mantis))
+  "@abstract"
+  (with-pp
+    (initialize-skeleton
+      obj
+      (the-as skeleton-group (art-group-get-by-name *level* "skel-mantis" (the-as (pointer uint32) #f)))
+      (the-as pair 0)
+      )
+    (enemy-method-113 obj *mantis-nav-enemy-info*)
+    (set! (-> obj flags) (mantis-flag))
+    (set! (-> obj my-up-vector quad) (-> *y-vector* quad))
+    (set! (-> obj gspot-normal quad) (-> *y-vector* quad))
+    (set! (-> obj gspot-timer) 0)
+    (set! (-> obj attack-timer) (+ (-> pp clock frame-counter) (seconds -5)))
+    (set! (-> obj track-timer) 0)
+    (set! (-> obj draw light-index) (the-as uint 30))
+    (none)
+    )
+  )
diff --git a/goal_src/jak2/levels/nest/nest-obs.gc b/goal_src/jak2/levels/nest/nest-obs.gc
index 17720bd1f1..ac2fa56e6a 100644
--- a/goal_src/jak2/levels/nest/nest-obs.gc
+++ b/goal_src/jak2/levels/nest/nest-obs.gc
@@ -7,3 +7,268 @@
 
 ;; DECOMP BEGINS
 
+(deftype nest-switch (process-drawable)
+  ((set-camera   symbol        :offset-assert 200)
+   (notify-actor entity-actor  :offset-assert 204)
+   (y-start      float         :offset-assert 208)
+   (y-delta      float         :offset-assert 212)
+   (y-rot-rate   float         :offset-assert 216)
+   )
+  :heap-base #x60
+  :method-count-assert 22
+  :size-assert         #xdc
+  :flag-assert         #x16006000dc
+  (:methods
+    (up () _type_ :state 20)
+    (down () _type_ :state 21)
+    )
+  )
+
+
+(defskelgroup skel-nest-switch cas-switch 0 2
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 2 0 3.5)
+              :origin-joint-index 3
+              )
+
+(defstate up (nest-switch)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('attack)
+       (let ((v1-1 (the-as attack-info (-> event param 1))))
+         (when (or (= (-> v1-1 mode) 'spin) (= (-> v1-1 mode) 'spin-air))
+           (let ((a1-3 (new 'stack-no-clear 'event-message-block)))
+             (set! (-> a1-3 from) (process->ppointer self))
+             (set! (-> a1-3 num-params) 0)
+             (set! (-> a1-3 message) 'trigger)
+             (let ((t9-0 send-event-function)
+                   (v1-6 (-> self notify-actor))
+                   )
+               (t9-0
+                 (if v1-6
+                     (-> v1-6 extra process)
+                     )
+                 a1-3
+                 )
+               )
+             )
+           (go-virtual down)
+           )
+         )
+       )
+      )
+    )
+  :trans (the-as (function none :behavior nest-switch) rider-trans)
+  :code (the-as (function none :behavior nest-switch) sleep-code)
+  :post (the-as (function none :behavior nest-switch) rider-post)
+  )
+
+(defstate down (nest-switch)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self set-camera) #f)
+    (none)
+    )
+  :trans (behavior ()
+    (when (and (not (-> self set-camera)) (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.6)))
+      (process-grab? *target* #f)
+      (hide-hud-quick #f)
+      (set-setting! 'process-mask 'set 0 (process-mask movie enemy))
+      (set-setting! 'entity-name "camera-253" 0 0)
+      (set! (-> self set-camera) #t)
+      )
+    (rider-trans)
+    (none)
+    )
+  :code (behavior ()
+    (set! (-> self y-rot-rate) 0.0)
+    (logclear! (-> self mask) (process-mask actor-pause))
+    (while (< 0.0 (-> self y-delta))
+      (seek! (-> self y-rot-rate) 500.0 (* 1000.0 (-> self clock seconds-per-frame)))
+      (quaternion-rotate-y!
+        (-> self root quat)
+        (-> self root quat)
+        (* 182.04445 (-> self clock seconds-per-frame) (-> self y-rot-rate))
+        )
+      (seek! (-> self y-delta) 0.0 (* 4096.0 (-> self clock seconds-per-frame) (* 0.006 (-> self y-rot-rate))))
+      (set! (-> self root trans y) (+ (-> self y-start) (-> self y-delta)))
+      (suspend)
+      )
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 1))
+        (seek! (-> self y-rot-rate) 0.0 (* 4000.0 (-> self clock seconds-per-frame)))
+        (quaternion-rotate-y!
+          (-> self root quat)
+          (-> self root quat)
+          (* 182.04445 (-> self clock seconds-per-frame) (-> self y-rot-rate))
+          )
+        (suspend)
+        )
+      )
+    (let ((gp-1 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-1) (seconds 1))
+        (suspend)
+        )
+      )
+    (remove-setting! 'entity-name)
+    (remove-setting! 'process-mask)
+    (process-release? *target*)
+    (logior! (-> self mask) (process-mask actor-pause))
+    (sleep-code)
+    (none)
+    )
+  :post (the-as (function none :behavior nest-switch) rider-post)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! nest-switch ((obj nest-switch) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (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))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak hit-by-others-list player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid no-standon))
+      (set-vector! (-> s3-0 local-sphere) 0.0 4096.0 0.0 20480.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (let ((v1-8 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-8 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-8 prim-core collide-with) (collide-spec jak hit-by-others-list 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 8192.0 0.0 14336.0)
+      )
+    (let ((v1-10 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 1))))
+      (set! (-> v1-10 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-10 prim-core collide-with) (collide-spec jak hit-by-others-list player-list))
+      (set! (-> v1-10 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-10 transform-index) 3)
+      (set-vector! (-> v1-10 local-sphere) 0.0 8192.0 0.0 14336.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 obstacle))
+      (set! (-> v1-12 prim-core action) (collide-action solid no-standon))
+      (set! (-> v1-12 transform-index) 3)
+      (set-vector! (-> v1-12 local-sphere) 0.0 8192.0 0.0 8192.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-nest-switch" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj notify-actor) (entity-actor-lookup arg0 'alt-actor 0))
+  (set! (-> obj y-start) (+ -12288.0 (-> obj root trans y)))
+  (set! (-> obj y-delta) 12288.0)
+  (go (method-of-object obj up))
+  (none)
+  )
+
+(deftype nest-piston (process-drawable)
+  ((y-level  float  :offset-assert 200)
+   (y-offset float  :offset-assert 204)
+   )
+  :heap-base #x50
+  :method-count-assert 22
+  :size-assert         #xd0
+  :flag-assert         #x16005000d0
+  (:methods
+    (idle () _type_ :state 20)
+    (up () _type_ :state 21)
+    )
+  )
+
+
+(defskelgroup skel-nest-piston piston piston-lod0-jg piston-idle-ja
+              ((piston-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+(defstate idle (nest-piston)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('trigger)
+       (go-virtual up)
+       )
+      )
+    )
+  :code (the-as (function none :behavior nest-piston) sleep-code)
+  )
+
+(defstate up (nest-piston)
+  :virtual #t
+  :trans (the-as (function none :behavior nest-piston) rider-trans)
+  :code (behavior ()
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 1))
+        (suspend)
+        )
+      )
+    (while (< (-> self y-offset) 16384.0)
+      (seek! (-> self y-offset) 16384.0 (* 8192.0 (-> self clock seconds-per-frame)))
+      (set! (-> self root trans y) (+ (-> self y-level) (-> self y-offset)))
+      (suspend)
+      )
+    (logior! (-> self mask) (process-mask actor-pause))
+    (sleep-code)
+    (none)
+    )
+  :post (the-as (function none :behavior nest-piston) rider-post)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! nest-piston ((obj nest-piston) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (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 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 29081.6 0.0 31948.8)
+      (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-nest-piston" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (set! (-> obj root trans y) (+ 8192.0 (-> obj root trans y)))
+  (set! (-> obj y-level) (-> obj root trans y))
+  (set! (-> obj y-offset) 0.0)
+  (transform-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
diff --git a/goal_src/jak2/levels/undefined/hal-h.gc b/goal_src/jak2/levels/undefined/hal-h.gc
index 6d1f64c669..bad063c952 100644
--- a/goal_src/jak2/levels/undefined/hal-h.gc
+++ b/goal_src/jak2/levels/undefined/hal-h.gc
@@ -9,24 +9,24 @@
 
 (deftype hal (bot)
   ((handle-failed-slave-id int8     :offset-assert 992)
-   (slave-handle           uint64 3 :offset-assert 1000)
+   (slave-handle           handle 3 :offset-assert 1000)
    )
   :heap-base #x380
   :method-count-assert 227
   :size-assert         #x400
   :flag-assert         #xe303800400
   (:methods
-    (hal-method-225 () none 225)
-    (hal-method-226 () none 226)
+    (hal-method-225 (_type_) symbol 225)
+    (hal-method-226 (_type_) symbol 226)
     )
   )
 
 
 (deftype halt-wait-spot (ai-task)
-  ((check-done   basic   :offset  32)
-   (which-spot   int8    :offset  36)
-   (num-spots    uint8   :offset  37)
-   (spot-indexes int8  6 :offset  38)
+  ((check-done   (function halt-wait-spot hal symbol)   :offset  32)
+   (which-spot   int8                                   :offset  36)
+   (num-spots    uint8                                  :offset  37)
+   (spot-indexes uint8                                6 :offset  38)
    )
   :method-count-assert 12
   :size-assert         #x30
diff --git a/goal_src/jak2/levels/undefined/hal-task.gc b/goal_src/jak2/levels/undefined/hal-task.gc
index 7fe13324b7..22cf8b56d4 100644
--- a/goal_src/jak2/levels/undefined/hal-task.gc
+++ b/goal_src/jak2/levels/undefined/hal-task.gc
@@ -7,3 +7,33 @@
 
 ;; DECOMP BEGINS
 
+(defmethod reset-task! halt-wait-spot ((obj halt-wait-spot))
+  "Virtual"
+  (set! (-> obj check-done) #f)
+  (set! (-> obj which-spot) 0)
+  (set! (-> obj num-spots) (the-as uint 1))
+  (none)
+  )
+
+;; WARN: Return type mismatch symbol vs none.
+(defmethod ai-task-method-11 halt-wait-spot ((obj halt-wait-spot) (arg0 bot))
+  "Virtual"
+  (let ((s4-0 (-> obj which-spot)))
+    (if (logtest? *display-bot-marks* (bot-marks-controls bmc16))
+        (bot-debug-draw-spot-sphere
+          arg0
+          (the-as int (-> obj num-spots))
+          (the-as (pointer uint) (-> obj spot-indexes))
+          (the-as int (-> obj spot-indexes s4-0))
+          )
+        )
+    (mem-copy!
+      (the-as pointer (-> arg0 spot))
+      (the-as pointer (-> arg0 course spots (-> obj spot-indexes s4-0)))
+      20
+      )
+    )
+  (set! (-> arg0 root-override2 trans quad) (-> arg0 spot center quad))
+  ((-> obj check-done) obj (the-as hal arg0))
+  (none)
+  )
diff --git a/goal_src/jak2/levels/undefined/hal.gc b/goal_src/jak2/levels/undefined/hal.gc
index c37db3bed7..97afb74124 100644
--- a/goal_src/jak2/levels/undefined/hal.gc
+++ b/goal_src/jak2/levels/undefined/hal.gc
@@ -7,3 +7,536 @@
 
 ;; DECOMP BEGINS
 
+(define *hal-nav-enemy-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 #f
+                               :hover-if-no-ground #f
+                               :idle-anim-script #f
+                               :idle-anim -1
+                               :notice-anim -1
+                               :hostile-anim -1
+                               :hit-anim -1
+                               :knocked-anim -1
+                               :knocked-land-anim -1
+                               :die-anim -1
+                               :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 30)
+                               :notice-distance-delta (meters 10)
+                               :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
+                               :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 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)
+                               :callback-info #f
+                               :use-momentum #f
+                               :use-frustration #t
+                               :use-stop-chase #f
+                               :use-circling #f
+                               :use-pacing #f
+                               :walk-anim -1
+                               :turn-anim -1
+                               :run-anim -1
+                               :taunt-anim -1
+                               :run-travel-speed (meters 6)
+                               :run-acceleration (meters 1)
+                               :run-turning-acceleration (meters 2)
+                               :walk-travel-speed (meters 3)
+                               :walk-acceleration (meters 1)
+                               :walk-turning-acceleration (meters 1)
+                               :maximum-rotation-rate (degrees 720.0)
+                               :notice-nav-radius (meters 1)
+                               :frustration-distance (meters 8)
+                               :frustration-time (seconds 4)
+                               :blocked-time (seconds 0.3)
+                               :circle-dist-lo 20480.0
+                               :circle-dist-hi 61440.0
+                               :nav-mesh #f
+                               )
+        )
+
+(set! (-> *hal-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+(defun hal-simple-check-too-far ((arg0 hal))
+  (let ((s5-0 (-> *target* control trans))
+        (f30-0 40960000.0)
+        )
+    (countdown (s4-0 3)
+      (let ((v1-6 (handle->process (-> arg0 slave-handle s4-0))))
+        (when v1-6
+          (let ((f0-0 (vector-vector-xz-distance s5-0 (-> (the-as process-drawable v1-6) root trans))))
+            (if (< f0-0 f30-0)
+                (set! f30-0 f0-0)
+                )
+            )
+          )
+        )
+      )
+    (let ((v0-1 0))
+      (let ((f0-1 (-> arg0 too-far-warn-dist)))
+        (when (>= f30-0 f0-1)
+          (if (>= (- f30-0 f0-1) (-> arg0 too-far-fail-dist-delta))
+              (set! v0-1 2)
+              (set! v0-1 1)
+              )
+          )
+        )
+      v0-1
+      )
+    )
+  )
+
+(defmethod stop-speech hal ((obj hal) (arg0 uint) (arg1 symbol))
+  (cond
+    ((zero? arg0)
+     (let ((t9-0 (method-of-type bot stop-speech)))
+       (t9-0 obj (-> obj channel) arg1)
+       )
+     (countdown (s4-0 3)
+       (let ((v1-4 (handle->process (-> obj slave-handle s4-0))))
+         (when v1-4
+           (let ((t9-1 (method-of-type bot stop-speech)))
+             (t9-1 (the-as bot v1-4) (-> v1-4 stack 580) arg1)
+             )
+           )
+         )
+       )
+     )
+    (else
+      ((method-of-type bot stop-speech) obj arg0 arg1)
+      )
+    )
+  (none)
+  )
+
+;; WARN: Return type mismatch gui-connection vs none.
+(defmethod play-speech hal ((obj hal) (arg0 int))
+  (let ((v1-2 (-> obj course speeches arg0)))
+    (logior! (-> v1-2 flags) (speech-flags playing))
+    (let ((a1-4 (-> v1-2 slave-id))
+          (t2-0 (-> v1-2 hold-time))
+          (gp-0 (-> obj course speech-tunings (-> v1-2 tuning-id)))
+          )
+      (cond
+        ((>= a1-4 0)
+         (let* ((a2-2 (handle->process (-> obj slave-handle a1-4)))
+                (a1-11 (add-process
+                         *gui-control*
+                         a2-2
+                         (the-as gui-channel (-> a2-2 stack 580))
+                         (gui-action play)
+                         (-> v1-2 name)
+                         -99.0
+                         (the-as time-frame t2-0)
+                         )
+                       )
+                )
+           (set-falloff! *gui-control* a1-11 (-> gp-0 trans?) (-> gp-0 fo-min) (-> gp-0 fo-max) (-> gp-0 fo-curve))
+           )
+         )
+        (else
+          (let ((a1-14 (add-process
+                         *gui-control*
+                         obj
+                         (the-as gui-channel (-> obj channel))
+                         (gui-action play)
+                         (-> v1-2 name)
+                         -99.0
+                         (the-as time-frame t2-0)
+                         )
+                       )
+                )
+            (set-falloff! *gui-control* a1-14 (-> gp-0 trans?) (-> gp-0 fo-min) (-> gp-0 fo-max) (-> gp-0 fo-curve))
+            )
+          )
+        )
+      )
+    )
+  (none)
+  )
+
+(defmethod channel-active? hal ((obj hal) (arg0 uint))
+  "Is the given [[gui-channel]] active?"
+  (cond
+    ((zero? arg0)
+     (let ((t9-0 (method-of-type bot channel-active?)))
+       (if (t9-0 obj (-> obj channel))
+           (return #t)
+           )
+       )
+     (countdown (s5-0 3)
+       (let ((v1-7 (handle->process (-> obj slave-handle s5-0))))
+         (when v1-7
+           (let ((t9-1 (method-of-type bot channel-active?)))
+             (if (t9-1 (the-as bot v1-7) (-> v1-7 stack 580))
+                 (return #t)
+                 )
+             )
+           )
+         )
+       )
+     #f
+     )
+    (else
+      ((method-of-type bot channel-active?) obj arg0)
+      )
+    )
+  )
+
+(defmethod hal-method-226 hal ((obj hal))
+  (countdown (s5-0 3)
+    (let ((a0-2 (handle->process (-> obj slave-handle s5-0))))
+      (when a0-2
+        (if (not (send-event a0-2 'request 'slave-id s5-0))
+            (return #f)
+            )
+        )
+      )
+    )
+  #t
+  )
+
+(defmethod hal-method-225 hal ((obj hal))
+  (countdown (v1-0 3)
+    (if (handle->process (-> obj slave-handle v1-0))
+        (return #f)
+        )
+    )
+  #t
+  )
+
+;; WARN: Return type mismatch symbol vs none.
+(defmethod bot-method-196 hal ((obj hal))
+  (when (not (logtest? (-> obj bot-flags) (bot-flags too-far-fail)))
+    (let ((t9-0 (method-of-type bot bot-method-196)))
+      (t9-0 obj)
+      )
+    (countdown (s5-0 3)
+      (let ((a0-3 (handle->process (-> obj slave-handle s5-0))))
+        (if a0-3
+            (bot-method-196 (the-as bot a0-3))
+            )
+        )
+      )
+    )
+  (none)
+  )
+
+(defmethod enemy-method-114 hal ((obj hal))
+  "@abstract"
+  (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)
+          )
+    (set! (-> s5-0 penetrated-by) (the-as penetrate -1))
+    (let ((v1-7 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set-vector! (-> v1-7 local-sphere) 0.0 0.0 0.0 40.96)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) v1-7)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-10 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-10 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-10 prim-core collide-with))
+      )
+    (set! (-> obj root-override2) s5-0)
+    )
+  0
+  (none)
+  )
+
+(defmethod init! hal ((obj hal))
+  "Set defaults for various fields."
+  (let ((t9-0 (method-of-type bot init!)))
+    (t9-0 obj)
+    )
+  (set! (-> obj handle-failed-slave-id) -1)
+  (countdown (v1-2 3)
+    (set! (-> obj slave-handle v1-2) (the-as handle #f))
+    (nop!)
+    )
+  0
+  (none)
+  )
+
+(defmethod enemy-method-115 hal ((obj hal))
+  "@abstract"
+  (init! obj)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-scenecamera" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (enemy-method-113 obj *hal-nav-enemy-info*)
+  (let ((t9-4 (method-of-type bot enemy-method-115)))
+    (t9-4 obj)
+    )
+  (set! (-> obj channel) (the-as uint 28))
+  (set! (-> obj spot-color) (the-as uint #x5000ffff))
+  (set! (-> obj notice-enemy-dist) 0.0)
+  (logior! (-> obj focus-status) (focus-status disable))
+  (let ((v1-13 (-> obj root-override2 root-prim)))
+    (set! (-> v1-13 prim-core collide-as) (collide-spec))
+    (set! (-> v1-13 prim-core collide-with) (collide-spec))
+    )
+  (set! (-> obj root-override2 backup-collide-as) (collide-spec))
+  (set! (-> obj root-override2 backup-collide-with) (collide-spec))
+  0
+  (logior! (-> obj draw status) (draw-control-status no-draw))
+  (remove-process-drawable (-> obj nav state mesh) obj)
+  (set! (-> obj nav) #f)
+  (set! (-> obj nav-mesh-index) -1)
+  0
+  (none)
+  )
+
+(defmethod scene-play hal ((obj hal) (arg0 string) (arg1 symbol))
+  "Spawn a [[scene-player]] process for the given scene."
+  (when (and (process-grab? obj #t) (or arg1 (process-grab? *target* #t)))
+    (countdown (s3-0 3)
+      (let ((a0-4 (handle->process (-> obj slave-handle s3-0))))
+        (if (and a0-4 (not (process-grab? a0-4 #t)))
+            (return #f)
+            )
+        )
+      )
+    (process-grab? obj #f)
+    (if (not arg1)
+        (process-grab? *target* #f)
+        )
+    (countdown (s4-1 3)
+      (let ((a0-10 (handle->process (-> obj slave-handle s4-1))))
+        (if a0-10
+            (process-grab? a0-10 #f)
+            )
+        )
+      )
+    (set! (-> obj scene-player-handle)
+          (ppointer->handle (process-spawn scene-player :init scene-player-init arg0 #t #f))
+          )
+    #t
+    )
+  )
+
+(defmethod scene-release? hal ((obj hal))
+  (when (not (handle->process (-> obj scene-player-handle)))
+    (process-release? obj)
+    (countdown (s5-0 3)
+      (let ((a0-7 (handle->process (-> obj slave-handle s5-0))))
+        (if a0-7
+            (process-release? a0-7)
+            )
+        )
+      )
+    #t
+    )
+  )
+
+;; WARN: Return type mismatch none vs object.
+(defmethod enemy-method-74 hal ((obj hal) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (the-as
+    object
+    (case arg2
+      (('notify)
+       (case (-> arg3 param 0)
+         (('hit-by)
+          (let* ((s4-0 arg0)
+                 (v1-2 (if (type? s4-0 bot)
+                           s4-0
+                           )
+                       )
+                 )
+            (when v1-2
+              (when (= (-> (the-as process (-> arg3 param 1)) type) target)
+                (logior! (-> obj bot-flags) (ash 1 (+ (-> (the-as bot v1-2) slave-id) 19)))
+                (the-as object (stop-speech obj (the-as uint 0) #t))
+                )
+              )
+            )
+          )
+         (('mission-failed)
+          (let* ((s4-1 arg0)
+                 (s5-1 (if (type? s4-1 bot)
+                           s4-1
+                           )
+                       )
+                 )
+            (when s5-1
+              (when (not (logtest? (-> obj bot-flags) (bot-flags too-far-fail)))
+                (when (not (logtest? (-> obj bot-flags) (bot-flags bf09)))
+                  (logior! (-> obj bot-flags) (bot-flags bf09))
+                  (let ((a1-7 (new 'stack-no-clear 'fail-mission-params)))
+                    (set! (-> a1-7 flags) (fail-mission-flags famflags-5))
+                    (set! (-> a1-7 message) (fail-mission-message fammsg-0))
+                    (set! (-> a1-7 retry-continue) #f)
+                    (set! (-> a1-7 fail-continue) #f)
+                    (set! (-> a1-7 reset-delay) (the-as uint 1500))
+                    (set! (-> a1-7 task) (game-task none))
+                    (set! (-> a1-7 fail-message) (game-text-id null))
+                    (if (start! *fail-mission-control* a1-7)
+                        (set! (-> obj handle-failed-slave-id) (-> (the-as bot s5-1) slave-id))
+                        )
+                    )
+                  (set! (-> obj delay-too-far-check) -1)
+                  (stop-speech obj (the-as uint 0) #f)
+                  (countdown (s4-2 3)
+                    (send-event (handle->process (-> obj slave-handle s4-2)) 'notify 'mission-failed)
+                    )
+                  )
+                (= (-> obj handle-failed-slave-id) (-> (the-as bot s5-1) slave-id))
+                )
+              )
+            )
+          )
+         (('follow-dir)
+          (set! (-> obj follow-dir quad) (-> (the-as vector (-> arg3 param 1)) quad))
+          #t
+          )
+         )
+       )
+      (('set-task)
+       (let ((a1-10 (/ (the-as int (-> arg3 param 0)) 8)))
+         (logior! (-> obj bot-task-bits) (ash 1 a1-10))
+         )
+       #t
+       )
+      (('clear-task)
+       (let ((a1-12 (/ (the-as int (-> arg3 param 0)) 8)))
+         (logclear! (-> obj bot-task-bits) (ash 1 a1-12))
+         )
+       #t
+       )
+      (('change-mode)
+       (when (= (-> arg3 param 0) 'grab)
+         (let ((v0-1 (the-as object (alive? obj))))
+           (if (and (the-as symbol v0-1) (-> arg3 param 1))
+               (logior! (-> obj focus-status) (focus-status grabbed))
+               )
+           v0-1
+           )
+         )
+       )
+      (('end-mode)
+       (when (logtest? (-> obj focus-status) (focus-status grabbed))
+         (logclear! (-> obj focus-status) (focus-status grabbed))
+         #t
+         )
+       )
+      (('skip)
+       (the-as object (skip-waypoint obj))
+       )
+      (('move-trans)
+       (move-to-point! (-> obj root-override2) (the-as vector (-> arg3 param 0)))
+       #t
+       )
+      (('die-fast)
+       (cleanup-for-death obj)
+       (go (method-of-object obj die-fast))
+       )
+      (('nav-mesh-kill)
+       (remove-process-drawable (-> obj nav state mesh) obj)
+       (set! (-> obj nav) #f)
+       (set! (-> obj nav-mesh-index) -1)
+       #t
+       )
+      )
+    )
+  )
+
+(defbehavior hal-post hal ()
+  (when (not (logtest? (-> self bot-flags) (bot-flags bf09)))
+    (let ((t9-0 (-> self waypoint on-update)))
+      (if t9-0
+          (t9-0 self)
+          )
+      )
+    )
+  (when (and (not (logtest? (-> self bot-flags) (bot-flags too-far-fail bf09))) (bot-check-too-far self))
+    (let ((gp-0 0))
+      (countdown (s5-0 3)
+        (let ((s4-0 (enemy-method-120 self 3 gp-0)))
+          (let ((a0-4 (handle->process (-> self slave-handle s4-0))))
+            (if (send-event a0-4 'request 'too-far-fail)
+                (goto cfg-24)
+                )
+            )
+          (set! gp-0 (logior gp-0 (ash 1 s4-0)))
+          )
+        )
+      )
+    )
+  (label cfg-24)
+  (if (not (logtest? (-> self bot-flags) (bot-flags bf09)))
+      (ai-task-control-method-10 (-> self ai-ctrl) self)
+      )
+  (if (logtest? *display-bot-marks* (bot-marks-controls bmc08))
+      (bot-debug-draw-spot-id self)
+      )
+  (none)
+  )
+
+(defbehavior hal-event-handler hal ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (enemy-method-74 self arg0 arg1 arg2 arg3)
+  )
+
+(defstate idle (hal)
+  :virtual #t
+  :event hal-event-handler
+  :enter (the-as (function none :behavior hal) nothing)
+  :exit (the-as (function none :behavior hal) nothing)
+  :trans (the-as (function none :behavior hal) nothing)
+  :code (the-as (function none :behavior hal) sleep-code)
+  :post hal-post
+  )
diff --git a/test/decompiler/reference/jak2/engine/util/smush-control-h_REF.gc b/test/decompiler/reference/jak2/engine/util/smush-control-h_REF.gc
index d28887b1f0..cc5c262380 100644
--- a/test/decompiler/reference/jak2/engine/util/smush-control-h_REF.gc
+++ b/test/decompiler/reference/jak2/engine/util/smush-control-h_REF.gc
@@ -11,6 +11,7 @@
    (damp-period float       :offset-assert  24)
    (ticks       float       :offset-assert  28)
    )
+  :pack-me
   :method-count-assert 15
   :size-assert         #x20
   :flag-assert         #xf00000020
diff --git a/test/decompiler/reference/jak2/levels/atoll/atoll-obs_REF.gc b/test/decompiler/reference/jak2/levels/atoll/atoll-obs_REF.gc
new file mode 100644
index 0000000000..720132e872
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/atoll/atoll-obs_REF.gc
@@ -0,0 +1,1563 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type piston
+(deftype piston (process-focusable)
+  ((sound-trans  vector     :inline :offset-assert 208)
+   (init-height  float              :offset-assert 224)
+   (range-top    float              :offset-assert 228)
+   (range-bottom float              :offset-assert 232)
+   (sound-time   time-frame 2       :offset-assert 240)
+   (sync         sync-eased :inline :offset-assert 256)
+   (piston-id    int32              :offset-assert 300)
+   (looping-id   uint32             :offset-assert 304)
+   )
+  :heap-base #xc0
+  :method-count-assert 31
+  :size-assert         #x134
+  :flag-assert         #x1f00c00134
+  (:methods
+    (idle () _type_ :state 27)
+    (dormant-down () _type_ :state 28)
+    (dormant-up () _type_ :state 29)
+    (running () _type_ :state 30)
+    )
+  )
+
+;; definition for method 3 of type piston
+(defmethod inspect piston ((obj piston))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-focusable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tsound-trans: #<vector @ #x~X>~%" (-> obj sound-trans))
+  (format #t "~2Tinit-height: ~f~%" (-> obj init-height))
+  (format #t "~2Trange-top: ~f~%" (-> obj range-top))
+  (format #t "~2Trange-bottom: ~f~%" (-> obj range-bottom))
+  (format #t "~2Tsound-time[2] @ #x~X~%" (-> obj sound-time))
+  (format #t "~2Tsync: #<sync-eased @ #x~X>~%" (-> obj sync))
+  (format #t "~2Tpiston-id: ~D~%" (-> obj piston-id))
+  (format #t "~2Tlooping-id: ~D~%" (-> obj looping-id))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-piston piston piston-lod0-jg piston-idle-ja
+              ((piston-lod0-mg (meters 20)) (piston-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0 -6.1 0 7.8)
+              )
+
+;; failed to figure out what this is:
+(defstate idle (piston)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as object (case event-type
+                     (('sync)
+                      (-> self sync)
+                      )
+                     )
+            )
+    )
+  :trans (behavior ()
+    (cond
+      ((logtest? (actor-option user17) (-> self fact options))
+       (if (task-complete? *game-info* (game-task atoll-sig))
+           (go-virtual running)
+           (go-virtual dormant-down)
+           )
+       )
+      ((= (-> self piston-id) 1)
+       (cond
+         ((task-complete? *game-info* (game-task atoll-sig))
+          (go-virtual running)
+          )
+         ((task-node-closed? (game-task-node atoll-sig-introduction))
+          (go-virtual dormant-up)
+          )
+         (else
+           (go-virtual dormant-down)
+           )
+         )
+       )
+      (else
+        (go-virtual running)
+        )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior piston) sleep-code)
+  )
+
+;; failed to figure out what this is:
+(defstate dormant-down (piston)
+  :virtual #t
+  :event (-> (method-of-type piston idle) event)
+  :code (the-as (function none :behavior piston) sleep-code)
+  )
+
+;; failed to figure out what this is:
+(defstate dormant-up (piston)
+  :virtual #t
+  :event (-> (method-of-type piston idle) event)
+  :enter (behavior ()
+    (let ((f1-1 (- (-> self range-top) (-> self range-bottom))))
+      (set! (-> self root-override trans y) (+ (-> self init-height) (+ (-> self range-bottom) f1-1)))
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior piston) transform-and-sleep)
+  )
+
+;; failed to figure out what this is:
+(defstate running (piston)
+  :virtual #t
+  :event (-> (method-of-type piston idle) event)
+  :enter (behavior ()
+    (if (logtest? (actor-option user18) (-> self fact options))
+        (set! (-> self sound-time 0) (+ (get-timeframe-offset! (-> self sync) 0) (seconds -0.1)))
+        )
+    (none)
+    )
+  :trans (the-as (function none :behavior piston) rider-trans)
+  :code (the-as (function none :behavior piston) sleep-code)
+  :post (behavior ()
+    (let ((f0-1 (- (-> self range-top) (-> self range-bottom))))
+      (set! (-> self root-override trans y)
+            (+ (-> self init-height) (+ (-> self range-bottom) (get-scaled-val! (-> self sync) f0-1 0)))
+            )
+      )
+    (when (and (logtest? (actor-option user18) (-> self fact options))
+               (< (-> self sound-time 0) (-> self clock frame-counter))
+               )
+      (sound-stop (the-as sound-id (-> self looping-id)))
+      (sound-play "piston-loop" :id (the-as sound-id (-> self looping-id)) :position (-> self sound-trans))
+      (+! (-> self sound-time 0) (the int (* 0.5 (the float (-> self sync period)))))
+      )
+    (rider-post)
+    (none)
+    )
+  )
+
+;; definition for method 10 of type piston
+(defmethod deactivate piston ((obj piston))
+  (sound-stop (the-as sound-id (-> obj looping-id)))
+  ((method-of-type process-focusable deactivate) obj)
+  (none)
+  )
+
+;; definition for method 11 of type piston
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! piston ((obj piston) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (local-vars (sv-64 res-tag))
+  (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 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 29081.6 0.0 31948.8)
+      (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-override) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (set! (-> obj sound-trans quad) (-> obj root-override trans quad))
+  (set! (-> obj root-override trans y) (+ 53248.0 (-> obj root-override trans y)))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-piston" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (logior! (-> obj focus-status) (focus-status ignore))
+  (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))
+        )
+  (set! (-> obj piston-id)
+        (res-lump-value (-> obj entity) 'extra-id int :default (the-as uint128 -1) :time -1000000000.0)
+        )
+  (let ((a1-8 (new 'stack-no-clear 'sync-info-params)))
+    (let ((v1-29 0))
+      (if #t
+          (set! v1-29 (logior v1-29 1))
+          )
+      (set! (-> a1-8 sync-type) 'sync-eased)
+      (set! (-> a1-8 sync-flags) (the-as sync-flags v1-29))
+      )
+    (set! (-> a1-8 period) (the-as uint 1500))
+    (set! (-> a1-8 entity) (-> obj entity))
+    (set! (-> a1-8 percent) 0.0)
+    (set! (-> a1-8 ease-in) 0.15)
+    (set! (-> a1-8 ease-out) 0.15)
+    (set! (-> a1-8 pause-in) 0.0)
+    (set! (-> a1-8 pause-out) 0.0)
+    (initialize! (-> obj sync) a1-8)
+    )
+  (let ((f28-0 -3.0)
+        (f30-0 3.0)
+        )
+    (set! sv-64 (new 'static 'res-tag))
+    (let ((v1-40 (res-lump-data arg0 'move-range (pointer float) :tag-ptr (& sv-64))))
+      (when v1-40
+        (set! f28-0 (-> v1-40 0))
+        (set! f30-0 (-> v1-40 1))
+        )
+      )
+    (set! (-> obj range-bottom) (* 4096.0 f28-0))
+    (set! (-> obj range-top) (* 4096.0 f30-0))
+    )
+  (set! (-> obj init-height) (-> obj root-override trans y))
+  (set! (-> obj root-override trans y) (+ -40960.0 (-> obj root-override trans y)))
+  (cond
+    ((logtest? (actor-option user18) (-> obj fact options))
+     (set! (-> obj looping-id) (the-as uint (new-sound-id)))
+     )
+    (else
+      (set! (-> obj looping-id) (the-as uint 0))
+      0
+      )
+    )
+  (ja-channel-push! 1 0)
+  (let ((a0-26 (-> obj skel root-channel 0)))
+    (set! (-> a0-26 frame-group) (the-as art-joint-anim (-> obj draw art-group data 3)))
+    (set! (-> a0-26 param 0) 1.0)
+    (set! (-> a0-26 frame-num) 0.0)
+    (joint-control-channel-group! a0-26 (the-as art-joint-anim (-> obj draw art-group data 3)) num-func-loop!)
+    )
+  (transform-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition of type turbine
+(deftype turbine (process-drawable)
+  ((dest-height float   :offset-assert 200)
+   (rise-height float   :offset-assert 204)
+   (rotspeed    float   :offset-assert 208)
+   (risen       symbol  :offset-assert 212)
+   )
+  :heap-base #x60
+  :method-count-assert 22
+  :size-assert         #xd8
+  :flag-assert         #x16006000d8
+  (:methods
+    (idle () _type_ :state 20)
+    (risen () _type_ :state 21)
+    )
+  )
+
+;; definition for method 3 of type turbine
+(defmethod inspect turbine ((obj turbine))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tdest-height: ~f~%" (-> obj dest-height))
+  (format #t "~2Trise-height: ~f~%" (-> obj rise-height))
+  (format #t "~2Trotspeed: ~f~%" (-> obj rotspeed))
+  (format #t "~2Trisen: ~A~%" (-> obj risen))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-turbine turbine turbine-lod0-jg -1
+              ((turbine-lod0-mg (meters 20)) (turbine-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0 -10 0 14)
+              )
+
+;; failed to figure out what this is:
+(defstate idle (turbine)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('rise)
+       (go-virtual risen)
+       )
+      )
+    )
+  :trans (behavior ()
+    (if (task-complete? *game-info* (game-task atoll-sig))
+        (go-virtual risen)
+        )
+    (rider-trans)
+    (none)
+    )
+  :code (the-as (function none :behavior turbine) sleep-code)
+  :post (behavior ()
+    (quaternion-rotate-y!
+      (-> self root quat)
+      (-> self root quat)
+      (* (-> self rotspeed) (-> self clock seconds-per-frame))
+      )
+    (let ((f1-2 (- (-> self dest-height) (-> self root trans y))))
+      (if (< 0.0 f1-2)
+          (+! (-> self root trans y) (* (fmax 6144.0 (* 0.5 f1-2)) (-> self clock seconds-per-frame)))
+          )
+      )
+    (update! (-> self sound))
+    (rider-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate risen (turbine)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self dest-height) (+ (-> self root trans y) (-> self rise-height)))
+    (none)
+    )
+  :trans (the-as (function none :behavior turbine) rider-trans)
+  :code (the-as (function none :behavior turbine) sleep-code)
+  :post (behavior ()
+    (quaternion-rotate-y!
+      (-> self root quat)
+      (-> self root quat)
+      (* (-> self rotspeed) (-> self clock seconds-per-frame))
+      )
+    (let ((f1-2 (- (-> self dest-height) (-> self root trans y))))
+      (if (< 0.0 f1-2)
+          (+! (-> self root trans y) (* (fmax 6144.0 (* 0.5 f1-2)) (-> self clock seconds-per-frame)))
+          )
+      )
+    (update! (-> self sound))
+    (rider-post)
+    (none)
+    )
+  )
+
+;; definition for method 11 of type turbine
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! turbine ((obj turbine) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (local-vars (sv-16 res-tag) (sv-32 res-tag))
+  (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 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) 0.0 32768.0 0.0 57344.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 root trans y) (+ 73728.0 (-> obj root trans y)))
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-turbine" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj dest-height) (-> obj root trans y))
+  (set! (-> obj risen) #f)
+  (let ((f30-0 8192.0)
+        (f28-0 0.0)
+        )
+    (set! sv-16 (new 'static 'res-tag))
+    (let ((v1-25 (res-lump-data arg0 'rotspeed pointer :tag-ptr (& sv-16))))
+      (if v1-25
+          (set! f30-0 (-> (the-as (pointer float) v1-25)))
+          )
+      )
+    (set! sv-32 (new 'static 'res-tag))
+    (let ((v1-27 (res-lump-data arg0 'rise-height pointer :tag-ptr (& sv-32))))
+      (if v1-27
+          (set! f28-0 (-> (the-as (pointer float) v1-27)))
+          )
+      )
+    (set! (-> obj rotspeed) f30-0)
+    (set! (-> obj rise-height) f28-0)
+    )
+  (set! (-> obj sound)
+        (new 'process 'ambient-sound (static-sound-spec "turbine" :fo-max 50) (-> obj root trans))
+        )
+  (ja-channel-push! 1 0)
+  (let ((a0-19 (-> obj skel root-channel 0)))
+    (set! (-> a0-19 frame-group) (the-as art-joint-anim (-> obj draw art-group data 3)))
+    (set! (-> a0-19 param 0) 1.0)
+    (set! (-> a0-19 frame-num) 0.0)
+    (joint-control-channel-group! a0-19 (the-as art-joint-anim (-> obj draw art-group data 3)) num-func-loop!)
+    )
+  (transform-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition of type liftcat
+(deftype liftcat (process-drawable)
+  ((up-y   float  :offset-assert 200)
+   (down-y float  :offset-assert 204)
+   )
+  :heap-base #x50
+  :method-count-assert 23
+  :size-assert         #xd0
+  :flag-assert         #x17005000d0
+  (:methods
+    (idle-up () _type_ :state 20)
+    (going-down () _type_ :state 21)
+    (idle-down () _type_ :state 22)
+    )
+  )
+
+;; definition for method 3 of type liftcat
+(defmethod inspect liftcat ((obj liftcat))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tup-y: ~f~%" (-> obj up-y))
+  (format #t "~2Tdown-y: ~f~%" (-> obj down-y))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-liftcat liftcat liftcat-lod0-jg liftcat-idle-ja
+              ((liftcat-lod0-mg (meters 20)) (liftcat-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0 -4 0 12.25)
+              )
+
+;; failed to figure out what this is:
+(defstate idle-up (liftcat)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('ridden 'edge-grabbed)
+       (go-virtual going-down)
+       )
+      (('query)
+       0
+       )
+      )
+    )
+  :trans (the-as (function none :behavior liftcat) rider-trans)
+  :code (the-as (function none :behavior liftcat) sleep-code)
+  :post (the-as (function none :behavior liftcat) rider-post)
+  )
+
+;; failed to figure out what this is:
+(defstate going-down (liftcat)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as object (case event-type
+                     (('query)
+                      1
+                      )
+                     )
+            )
+    )
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (sound-play "liftcat")
+    (none)
+    )
+  :trans (behavior ()
+    (rider-trans)
+    (let ((gp-0 (-> self root)))
+      (if (>= (-> self down-y) (-> gp-0 trans y))
+          (go-virtual idle-down)
+          )
+      (if (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.5))
+          (set! (-> self root transv y) -8192.0)
+          (set! (-> self root transv y) 0.0)
+          )
+      (vector-v++! (-> gp-0 trans) (-> gp-0 transv))
+      (if (>= (-> self down-y) (-> gp-0 trans y))
+          (set! (-> gp-0 trans y) (-> self down-y))
+          )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior liftcat) sleep-code)
+  :post (the-as (function none :behavior liftcat) rider-post)
+  )
+
+;; failed to figure out what this is:
+(defstate idle-down (liftcat)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as object (case event-type
+                     (('query)
+                      2
+                      )
+                     )
+            )
+    )
+  :enter (behavior ()
+    (process-entity-status! self (entity-perm-status subtask-complete) #t)
+    (none)
+    )
+  :code (the-as (function none :behavior liftcat) sleep-code)
+  )
+
+;; definition for method 11 of type liftcat
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! liftcat ((obj liftcat) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (local-vars (sv-16 res-tag) (sv-32 res-tag))
+  (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 rideable))
+      (set! (-> s3-0 transform-index) 3)
+      (set-vector! (-> s3-0 local-sphere) 0.0 40960.0 0.0 50176.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)
+  (let ((s4-1 (-> obj root)))
+    (set! sv-16 (new 'static 'res-tag))
+    (let ((v1-15 (res-lump-data arg0 'trans-offset vector :tag-ptr (& sv-16))))
+      (when v1-15
+        (+! (-> s4-1 trans x) (-> v1-15 x))
+        (+! (-> s4-1 trans y) (-> v1-15 y))
+        (+! (-> s4-1 trans z) (-> v1-15 z))
+        )
+      )
+    (set! sv-32 (new 'static 'res-tag))
+    (let ((v1-17 (res-lump-data arg0 'scale-mult vector :tag-ptr (& sv-32))))
+      (when v1-17
+        (set! (-> s4-1 scale x) (* (-> s4-1 scale x) (-> v1-17 x)))
+        (set! (-> s4-1 scale y) (* (-> s4-1 scale y) (-> v1-17 y)))
+        (set! (-> s4-1 scale z) (* (-> s4-1 scale z) (-> v1-17 z)))
+        )
+      )
+    )
+  (set! (-> obj root trans y) (+ 55558.145 (-> obj root trans y)))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-liftcat" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (let ((v1-24 (-> obj root)))
+    (set! (-> obj down-y) (-> v1-24 trans y))
+    (set! (-> v1-24 trans y) (+ 28672.0 (-> v1-24 trans y)))
+    (set! (-> obj up-y) (-> v1-24 trans y))
+    (vector-reset! (-> v1-24 transv))
+    )
+  (ja-channel-set! 1)
+  (let ((s5-2 (-> obj skel root-channel 0)))
+    (joint-control-channel-group-eval!
+      s5-2
+      (the-as art-joint-anim (-> obj draw art-group data 3))
+      num-func-identity
+      )
+    (set! (-> s5-2 frame-num) 0.0)
+    )
+  (if (task-complete? *game-info* (game-task atoll-sig))
+      (process-entity-status! obj (entity-perm-status subtask-complete) #t)
+      )
+  (cond
+    ((and (-> obj entity) (logtest? (-> obj entity extra perm status) (entity-perm-status subtask-complete)))
+     (set! (-> obj root trans y) (-> obj down-y))
+     (transform-post)
+     (go (method-of-object obj idle-down))
+     )
+    (else
+      (set! (-> obj root trans y) (-> obj up-y))
+      (transform-post)
+      (go (method-of-object obj idle-up))
+      )
+    )
+  (none)
+  )
+
+;; definition of type atollrotpipe
+(deftype atollrotpipe (process-drawable)
+  ((root-override collide-shape-moving         :offset 128)
+   (smush         smush-control        :inline :offset 200)
+   (init-quat     quaternion           :inline :offset 240)
+   (rot-angle     float                        :offset 256)
+   (shudder-angle float                        :offset 260)
+   (cycle-time    float                        :offset 264)
+   (cycle-offset  float                        :offset 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 atollrotpipe
+(defmethod inspect atollrotpipe ((obj atollrotpipe))
+  (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 smush))
+  (format #t "~2Tinit-quat: #<quaternion @ #x~X>~%" (-> obj init-quat))
+  (format #t "~2Trot-angle: ~f~%" (-> obj rot-angle))
+  (format #t "~2Tshudder-angle: ~f~%" (-> obj shudder-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-atollrotpipe atollrotpipe atollrotpipe-lod0-jg -1
+              ((atollrotpipe-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 16)
+              )
+
+;; failed to figure out what this is:
+(defstate idle (atollrotpipe)
+  :virtual #t
+  :trans (behavior ()
+    (rider-trans)
+    (let ((a1-0 (new 'stack-no-clear 'vector)))
+      (set! (-> a1-0 x) 0.0)
+      (set! (-> a1-0 y) 0.0)
+      (set! (-> a1-0 z) 1.0)
+      (set! (-> a1-0 w) 1.0)
+      (let ((a2-1 (quaternion-vector-angle!
+                    (new 'stack-no-clear 'quaternion)
+                    a1-0
+                    (+ (-> self rot-angle) (-> self shudder-angle))
+                    )
+                  )
+            )
+        (quaternion*! (-> self root-override quat) (-> self init-quat) a2-1)
+        )
+      )
+    (none)
+    )
+  :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)
+          )
+        )
+      (activate! (-> self smush) -1.0 60 225 1.0 1.0 (-> self clock))
+      (sound-play "rot-pipe-wiggle" :position (-> self root-override trans))
+      (let ((gp-3 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-3) (seconds 0.75))
+          (set! (-> self shudder-angle) (* 364.0889 (update! (-> self smush))))
+          (suspend)
+          )
+        )
+      (set! (-> self shudder-angle) 0.0)
+      (set-zero! (-> self smush))
+      (let ((gp-4 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-4) (seconds 0.25))
+          (suspend)
+          )
+        )
+      (sound-play "rot-pipe-turn" :position (-> self root-override trans))
+      (let* ((f0-7 2.0)
+             (f30-1 (* 16384.0 f0-7))
+             (gp-6 (-> self clock frame-counter))
+             )
+        (until (>= (- (-> self clock frame-counter) gp-6) (seconds 0.5))
+          (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 #x4000))
+        (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 ()
+    (rider-post)
+    (none)
+    )
+  )
+
+;; definition for method 11 of type atollrotpipe
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! atollrotpipe ((obj atollrotpipe) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (local-vars (sv-16 res-tag))
+  (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 rideable))
+      (set! (-> s3-0 transform-index) 3)
+      (set-vector! (-> s3-0 local-sphere) 0.0 0.0 0.0 65536.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-override) (the-as collide-shape-moving s4-0))
+    )
+  (set! (-> obj root-override rider-max-momentum) 8192.0)
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-atollrotpipe" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (set! (-> obj rot-angle) 0.0)
+  (set! (-> obj shudder-angle) 0.0)
+  (quaternion-copy! (-> obj init-quat) (-> obj root-override quat))
+  (ja-channel-push! 1 0)
+  (let ((s4-2 (-> obj skel root-channel 0)))
+    (joint-control-channel-group-eval!
+      s4-2
+      (the-as art-joint-anim (-> obj draw art-group data 2))
+      num-func-identity
+      )
+    (set! (-> s4-2 frame-num) 0.0)
+    )
+  (transform-post)
+  (let ((f28-0 4.0)
+        (f30-0 0.0)
+        )
+    (set! sv-16 (new 'static 'res-tag))
+    (let ((v1-29 (res-lump-data arg0 'cycle-speed (pointer float) :tag-ptr (& sv-16))))
+      (when v1-29
+        (set! f28-0 (-> v1-29 0))
+        (set! f30-0 (-> v1-29 1))
+        )
+      )
+    (set! (-> obj cycle-time) (the float (max 0 (+ (the int (* 300.0 f28-0)) -375))))
+    (set! (-> obj cycle-offset) (the float (the int (* 300.0 f30-0))))
+    )
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition of type slider
+(deftype slider (process-drawable)
+  ((root-override     collide-shape-moving           :offset        128)
+   (path-pos          float                          :offset-assert 200)
+   (sync              sync-eased           :inline   :offset-assert 208)
+   (attack-id         uint32                         :offset-assert 252)
+   (sound-id          uint32                         :offset-assert 256)
+   (collide-off-timer uint64                         :offset-assert 264)
+   (l-points          vector               6 :inline :offset-assert 272)
+   (l-bolts           lightning-control    4         :offset-assert 368)
+   )
+  :heap-base #x100
+  :method-count-assert 21
+  :size-assert         #x180
+  :flag-assert         #x1501000180
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+;; definition for method 3 of type slider
+(defmethod inspect slider ((obj slider))
+  (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 "~2Tsync: #<sync-eased @ #x~X>~%" (-> obj sync))
+  (format #t "~2Tattack-id: ~D~%" (-> obj attack-id))
+  (format #t "~2Tsound-id: ~D~%" (-> obj sound-id))
+  (format #t "~2Tcollide-off-timer: ~D~%" (-> obj collide-off-timer))
+  (format #t "~2Tl-points[6] @ #x~X~%" (-> obj l-points))
+  (format #t "~2Tl-bolts[4] @ #x~X~%" (-> obj l-bolts))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-slider slider slider-lod0-jg -1
+              ((slider-lod0-mg (meters 20)) (slider-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 7)
+              )
+
+;; failed to figure out what this is:
+(defstate idle (slider)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as
+      object
+      (case event-type
+        (('touch 'attack)
+         (when (>= (- (-> self clock frame-counter) (the-as int (-> self collide-off-timer))) (seconds 2))
+           (let* ((s4-0 proc)
+                  (s3-0 (if (type? s4-0 process-focusable)
+                            s4-0
+                            )
+                        )
+                  )
+             (when s3-0
+               (let ((s4-1 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override quat))))
+                 (let* ((v1-7 (vector-z-quaternion! (new 'stack-no-clear 'vector) (get-quat (the-as process-focusable s3-0) 0)))
+                        (f0-1 (vector-dot s4-1 v1-7))
+                        )
+                   (if (< 0.0 f0-1)
+                       (vector-float*! s4-1 s4-1 -1.0)
+                       )
+                   )
+                 (sound-play "slide-zap")
+                 (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-or-shove)
+                   (set! (-> a1-8 param 0) (-> event param 0))
+                   (let ((v1-17 (new 'static 'attack-info :mask (attack-info-mask vector shove-back shove-up id))))
+                     (set! (-> v1-17 id) (-> self attack-id))
+                     (set! (-> v1-17 vector quad) (-> s4-1 quad))
+                     (set! (-> v1-17 shove-back) 32768.0)
+                     (set! (-> v1-17 shove-up) 12288.0)
+                     (set! (-> a1-8 param 1) (the-as uint v1-17))
+                     )
+                   (send-event-function proc a1-8)
+                   )
+                 )
+               (let ((v0-0 (-> self clock frame-counter)))
+                 (set! (-> self collide-off-timer) (the-as uint v0-0))
+                 v0-0
+                 )
+               )
+             )
+           )
+         )
+        )
+      )
+    )
+  :code (the-as (function none :behavior slider) sleep-code)
+  :post (behavior ()
+    (let ((f30-0 (get-norm! (-> self sync) 0)))
+      (set! (-> self path-pos) f30-0)
+      (get-point-at-percent-along-path! (-> self path) (-> self root-override trans) (-> self path-pos) 'interp)
+      (let ((f0-3 (sin-rad (* 3.1415925 f30-0))))
+        (update-vol! (-> self sound) (sqrtf f0-3))
+        )
+      )
+    (update-trans! (-> self sound) (-> self root-override trans))
+    (let ((a1-4 (new 'stack-no-clear 'overlaps-others-params)))
+      (set! (-> a1-4 options) (overlaps-others-options oo0))
+      (set! (-> a1-4 collide-with-filter) (the-as collide-spec -1))
+      (set! (-> a1-4 tlist) *touching-list*)
+      (find-overlapping-shapes (-> self root-override) a1-4)
+      )
+    (let ((v1-17 (-> self root-override trans))
+          (a0-6 (-> self l-bolts))
+          (a1-5 (-> self l-points))
+          )
+      (dotimes (a2-1 4)
+        (let* ((t1-0 (if (>= 1 a2-1)
+                         a2-1
+                         (+ a2-1 1)
+                         )
+                     )
+               (t0-1 (vector+! (new 'stack-no-clear 'vector) v1-17 (-> a1-5 t1-0)))
+               (a3-4 (vector+! (new 'stack-no-clear 'vector) v1-17 (-> a1-5 (+ t1-0 1))))
+               )
+          (set! (-> a0-6 a2-1 state meet data 0 quad) (-> t0-1 quad))
+          (let ((t0-5 (-> a0-6 a2-1)))
+            (set! (-> t0-5 state meet data (+ (-> t0-5 state points-to-draw) -1) quad) (-> a3-4 quad))
+            )
+          )
+        )
+      )
+    (sound-play "slide-lightning" :id (the-as sound-id (-> self sound-id)))
+    (update! (-> self sound))
+    (transform-post)
+    (none)
+    )
+  )
+
+;; definition for method 12 of type slider
+(defmethod run-logic? slider ((obj slider))
+  #t
+  )
+
+;; definition for method 10 of type slider
+(defmethod deactivate slider ((obj slider))
+  (sound-stop (the-as sound-id (-> obj sound-id)))
+  ((the-as (function process-drawable none) (find-parent-method slider 10)) obj)
+  (none)
+  )
+
+;; definition for method 7 of type slider
+;; WARN: Return type mismatch process-drawable vs slider.
+(defmethod relocate slider ((obj slider) (arg0 int))
+  (dotimes (v1-0 4)
+    (if (nonzero? (-> obj l-bolts v1-0))
+        (&+! (-> obj l-bolts v1-0) arg0)
+        )
+    )
+  (the-as
+    slider
+    ((the-as (function process-drawable int process-drawable) (find-parent-method slider 7)) obj arg0)
+    )
+  )
+
+;; definition for method 11 of type slider
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! slider ((obj slider) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum 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 player-list))
+      (set! (-> v1-2 transform-index) 0)
+      (set-vector! (-> v1-2 local-sphere) 0.0 0.0 0.0 28672.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) (the-as collide-shape-moving s4-0))
+    )
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-slider" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (let ((a1-7 (new 'stack-no-clear 'sync-info-params)))
+    (let ((v1-12 0))
+      (if #t
+          (set! v1-12 (logior v1-12 1))
+          )
+      (set! (-> a1-7 sync-type) 'sync-eased)
+      (set! (-> a1-7 sync-flags) (the-as sync-flags v1-12))
+      )
+    (set! (-> a1-7 period) (the-as uint 2400))
+    (set! (-> a1-7 entity) (-> obj entity))
+    (set! (-> a1-7 percent) 0.0)
+    (set! (-> a1-7 ease-in) 0.15)
+    (set! (-> a1-7 ease-out) 0.15)
+    (set! (-> a1-7 pause-in) 0.0)
+    (set! (-> a1-7 pause-out) 0.0)
+    (initialize! (-> obj sync) a1-7)
+    )
+  (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))
+  (set! (-> obj path-pos) 0.0)
+  (let* ((v1-24 *game-info*)
+         (a0-20 (+ (-> v1-24 attack-id) 1))
+         )
+    (set! (-> v1-24 attack-id) a0-20)
+    (set! (-> obj attack-id) a0-20)
+    )
+  (set! (-> obj sound-id) (the-as uint (new-sound-id)))
+  (set! (-> obj collide-off-timer) (the-as uint 0))
+  (set-vector! (-> obj l-points 0) 19660.8 20480.0 1638.4 0.0)
+  (set-vector! (-> obj l-points 1) 0.0 24576.0 1638.4 0.0)
+  (set-vector! (-> obj l-points 2) -19660.8 20480.0 1638.4 0.0)
+  (set-vector! (-> obj l-points 3) 19660.8 20480.0 -1638.4 0.0)
+  (set-vector! (-> obj l-points 4) 0.0 24576.0 -1638.4 0.0)
+  (set-vector! (-> obj l-points 5) -19660.8 20480.0 -1638.4 0.0)
+  (let ((s5-2
+          (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 4096.0
+            :merge-factor 0.5
+            :merge-count 2
+            :radius 3072.0
+            :duration -1.0
+            :sound #f
+            )
+          )
+        (s4-2 (-> obj l-points))
+        (s3-0 (-> obj root-override trans))
+        )
+    (dotimes (s2-0 4)
+      (set! (-> obj l-bolts s2-0) (new 'process 'lightning-control s5-2 obj 0.0))
+      (let* ((a1-10 (if (< s2-0 1)
+                        (+ s2-0 1)
+                        s2-0
+                        )
+                    )
+             (a0-39 (vector+! (new 'stack-no-clear 'vector) s3-0 (-> s4-2 a1-10)))
+             (v1-37 (vector+! (new 'stack-no-clear 'vector) s3-0 (-> s4-2 (+ a1-10 1))))
+             )
+        (set! (-> obj l-bolts s2-0 state meet data 0 quad) (-> a0-39 quad))
+        (let ((a0-43 (-> obj l-bolts s2-0)))
+          (set! (-> a0-43 state meet data (+ (-> a0-43 state points-to-draw) -1) quad) (-> v1-37 quad))
+          )
+        )
+      )
+    )
+  (set! (-> obj sound)
+        (new 'process 'ambient-sound (static-sound-spec "slider" :fo-max 50) (-> obj root-override trans))
+        )
+  (ja-channel-push! 1 0)
+  (let ((s5-3 (-> obj skel root-channel 0)))
+    (joint-control-channel-group-eval!
+      s5-3
+      (the-as art-joint-anim (-> obj draw art-group data 3))
+      num-func-identity
+      )
+    (set! (-> s5-3 frame-num) 0.0)
+    )
+  (transform-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition of type atoll-windmill
+(deftype atoll-windmill (process-drawable)
+  ((sync         sync-linear :inline :offset-assert 200)
+   (blade-normal vector      :inline :offset-assert 224)
+   (orig-quat    quaternion  :inline :offset-assert 240)
+   )
+  :heap-base #x80
+  :method-count-assert 21
+  :size-assert         #x100
+  :flag-assert         #x1500800100
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+;; definition for method 3 of type atoll-windmill
+(defmethod inspect atoll-windmill ((obj atoll-windmill))
+  (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 "~2Tblade-normal: #<vector @ #x~X>~%" (-> obj blade-normal))
+  (format #t "~2Torig-quat: #<quaternion @ #x~X>~%" (-> obj orig-quat))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-atoll-windmill atoll-windmill atoll-windmill-lod0-jg -1
+              ((atoll-windmill-lod0-mg (meters 20))
+               (atoll-windmill-lod1-mg (meters 40))
+               (atoll-windmill-lod2-mg (meters 999999))
+               )
+              :bounds (static-spherem 0 0 0 62)
+              :longest-edge (meters 21.191)
+              )
+
+;; failed to figure out what this is:
+(defstate idle (atoll-windmill)
+  :virtual #t
+  :code (the-as (function none :behavior atoll-windmill) sleep-code)
+  :post (behavior ()
+    (let ((f0-0 (get-scaled-val! (-> self sync) -65536.0 0)))
+      (quaternion-axis-angle!
+        (-> self root quat)
+        (-> self blade-normal x)
+        (-> self blade-normal y)
+        (-> self blade-normal z)
+        f0-0
+        )
+      )
+    (quaternion*! (-> self root quat) (-> self root quat) (-> self orig-quat))
+    (quaternion-normalize! (-> self root quat))
+    (update! (-> self sound))
+    (ja-post)
+    (none)
+    )
+  )
+
+;; definition for method 11 of type atoll-windmill
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! atoll-windmill ((obj atoll-windmill) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (set! (-> obj mask) (logior (process-mask ambient) (-> obj mask)))
+  (let ((a1-1 (new 'stack-no-clear 'sync-info-params)))
+    (let ((v1-2 0))
+      (if #f
+          (set! v1-2 (logior v1-2 1))
+          )
+      (set! (-> a1-1 sync-type) 'sync-linear)
+      (set! (-> a1-1 sync-flags) (the-as sync-flags v1-2))
+      )
+    (set! (-> a1-1 entity) arg0)
+    (set! (-> a1-1 period) (the-as uint 3000))
+    (set! (-> a1-1 percent) 0.0)
+    (initialize! (-> obj sync) a1-1)
+    )
+  (set! (-> obj root) (new 'process 'trsqv))
+  (process-drawable-from-entity! obj arg0)
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-atoll-windmill" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (quaternion-copy! (-> obj orig-quat) (-> obj root quat))
+  (vector-z-quaternion! (-> obj blade-normal) (-> obj root quat))
+  (vector-normalize! (-> obj blade-normal) 1.0)
+  (set! (-> obj sound)
+        (new 'process 'ambient-sound (static-sound-spec "atoll-windmill" :fo-max 50) (-> obj root trans))
+        )
+  (ja-channel-push! 1 0)
+  (let ((s5-2 (-> obj skel root-channel 0)))
+    (joint-control-channel-group-eval!
+      s5-2
+      (the-as art-joint-anim (-> obj draw art-group data 4))
+      num-func-identity
+      )
+    (set! (-> s5-2 frame-num) 0.0)
+    )
+  (ja-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition of type atoll-valve
+(deftype atoll-valve (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 atoll-valve
+(defmethod inspect atoll-valve ((obj atoll-valve))
+  (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-atoll-valve atoll-valve atoll-valve-lod0-jg atoll-valve-idle-ja
+              ((atoll-valve-lod0-mg (meters 20)) (atoll-valve-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 1)
+              :origin-joint-index 3
+              )
+
+;; failed to figure out what this is:
+(defstate idle (atoll-valve)
+  :virtual #t
+  :code (the-as (function none :behavior atoll-valve) sleep-code)
+  )
+
+;; definition for method 11 of type atoll-valve
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! atoll-valve ((obj atoll-valve) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (set! (-> obj mask) (logior (process-mask ambient) (-> obj mask)))
+  (set! (-> obj root) (new 'process 'trsqv))
+  (process-drawable-from-entity! obj arg0)
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-atoll-valve" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (ja-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition of type atoll-hatch
+(deftype atoll-hatch (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 atoll-hatch
+(defmethod inspect atoll-hatch ((obj atoll-hatch))
+  (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-atoll-hatch atoll-hatch atoll-hatch-lod0-jg atoll-hatch-idle-ja
+              ((atoll-hatch-lod0-mg (meters 20)) (atoll-hatch-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0.7 0 0 1.1)
+              :origin-joint-index 3
+              )
+
+;; failed to figure out what this is:
+(defstate idle (atoll-hatch)
+  :virtual #t
+  :code (the-as (function none :behavior atoll-hatch) sleep-code)
+  )
+
+;; definition for method 11 of type atoll-hatch
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! atoll-hatch ((obj atoll-hatch) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (set! (-> obj mask) (logior (process-mask ambient) (-> obj mask)))
+  (set! (-> obj root) (new 'process 'trsqv))
+  (process-drawable-from-entity! obj arg0)
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-atoll-hatch" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (cond
+    ((task-complete? *game-info* (game-task atoll-water))
+     (let ((a0-8 (-> obj skel root-channel 0)))
+       (set! (-> a0-8 frame-group) (the-as art-joint-anim (-> obj draw art-group data 3)))
+       (set! (-> a0-8 param 0)
+             (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 3)) frames num-frames) -1))
+             )
+       (set! (-> a0-8 param 1) 1.0)
+       (set! (-> a0-8 frame-num) 1.0)
+       (joint-control-channel-group! a0-8 (the-as art-joint-anim (-> obj draw art-group data 3)) num-func-seek!)
+       )
+     )
+    (else
+      (let ((a0-9 (-> obj skel root-channel 0)))
+        (set! (-> a0-9 frame-group) (the-as art-joint-anim (-> obj draw art-group data 3)))
+        (set! (-> a0-9 param 0)
+              (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 3)) frames num-frames) -1))
+              )
+        (set! (-> a0-9 param 1) 1.0)
+        (set! (-> a0-9 frame-num) 0.0)
+        (joint-control-channel-group! a0-9 (the-as art-joint-anim (-> obj draw art-group data 3)) num-func-seek!)
+        )
+      )
+    )
+  (ja-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition of type atoll-hellcat
+(deftype atoll-hellcat (process-drawable)
+  ()
+  :heap-base #x50
+  :method-count-assert 22
+  :size-assert         #xc8
+  :flag-assert         #x16005000c8
+  (:methods
+    (die-fast () _type_ :state 20)
+    (idle () _type_ :state 21)
+    )
+  )
+
+;; definition for method 3 of type atoll-hellcat
+(defmethod inspect atoll-hellcat ((obj atoll-hellcat))
+  (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:
+(defstate idle (atoll-hellcat)
+  :virtual #t
+  :code (the-as (function none :behavior atoll-hellcat) sleep-code)
+  )
+
+;; failed to figure out what this is:
+(defstate die-fast (atoll-hellcat)
+  :virtual #t
+  :code (behavior ()
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+;; definition for method 11 of type atoll-hellcat
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! atoll-hellcat ((obj atoll-hellcat) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (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 0.0 0.0 34816.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-atoll-hellcat" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (let ((a1-7 (new 'stack-no-clear 'vector)))
+    (set-vector! a1-7 0.0 19441.436 0.0 1.0)
+    (quaternion-zxy! (-> obj root quat) a1-7)
+    )
+  (transform-post)
+  (if (task-complete? *game-info* (game-task atoll-battle))
+      (go (method-of-object obj die-fast))
+      (go (method-of-object obj idle))
+      )
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-atoll-mar-symbol atoll-mar-symbol atoll-mar-symbol-lod0-jg atoll-mar-symbol-idle-ja
+              ((atoll-mar-symbol-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 0.6)
+              :origin-joint-index 3
+              )
+
+;; definition of type atoll-mar-symbol
+(deftype atoll-mar-symbol (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 atoll-mar-symbol
+(defmethod inspect atoll-mar-symbol ((obj atoll-mar-symbol))
+  (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:
+(defstate idle (atoll-mar-symbol)
+  :virtual #t
+  :code (the-as (function none :behavior atoll-mar-symbol) sleep-code)
+  )
+
+;; definition for method 11 of type atoll-mar-symbol
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! atoll-mar-symbol ((obj atoll-mar-symbol) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (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-atoll-mar-symbol" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (ja-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; failed to figure out what this is:
+(set-subtask-hook!
+  *game-info*
+  18
+  3
+  (lambda :behavior task-manager
+    ()
+    (local-vars (v1-31 symbol))
+    (set! (-> self data-int32 0) 0)
+    (set! (-> self beep-time) (-> self clock frame-counter))
+    (until #f
+      (when (>= (- (-> self clock frame-counter) (-> self beep-time)) (seconds 40))
+        (let ((v1-7 (logand (-> self data-int32 0) 3)))
+          (cond
+            ((zero? v1-7)
+             (talker-spawn-func (-> *talker-speech* 68) *entity-pool* (target-pos 0) (the-as region #f))
+             )
+            ((= v1-7 1)
+             (talker-spawn-func (-> *talker-speech* 69) *entity-pool* (target-pos 0) (the-as region #f))
+             )
+            ((= v1-7 2)
+             (talker-spawn-func (-> *talker-speech* 70) *entity-pool* (target-pos 0) (the-as region #f))
+             )
+            ((= v1-7 3)
+             (talker-spawn-func (-> *talker-speech* 71) *entity-pool* (target-pos 0) (the-as region #f))
+             )
+            )
+          )
+        (set! (-> self beep-time) (-> self clock frame-counter))
+        (+! (-> self data-int32 0) 1)
+        )
+      (b!
+        (>= (vector-vector-distance (target-pos 0) (-> self info end-sphere)) (-> self info end-sphere r))
+        cfg-20
+        :delay #f
+        )
+      (send-event (handle->process (-> self arrow)) 'leave)
+      (b! #t cfg-36 :delay (nop!))
+      (label cfg-20)
+      (let ((a0-21 (>= (-> self data-int32 0) 4)))
+        (b! (not a0-21) cfg-29 :likely-delay (set! v1-31 a0-21))
+        )
+      (set! v1-31 (not (handle->process (-> self arrow))))
+      (label cfg-29)
+      (when v1-31
+        (let ((gp-5 (new 'stack-no-clear 'task-arrow-params)))
+          (set! (-> gp-5 pos quad) (-> self info end-sphere quad))
+          (quaternion-identity! (-> gp-5 quat))
+          (set! (-> gp-5 flags) (task-arrow-flags))
+          (set! (-> gp-5 map-icon) (the-as uint 15))
+          (set! (-> self arrow) (process->handle (task-arrow-spawn gp-5 (the-as task-arrow self))))
+          )
+        )
+      (label cfg-36)
+      (suspend)
+      )
+    #f
+    )
+  )
diff --git a/test/decompiler/reference/jak2/levels/atoll/atoll-tank_REF.gc b/test/decompiler/reference/jak2/levels/atoll/atoll-tank_REF.gc
new file mode 100644
index 0000000000..17de8b16f2
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/atoll/atoll-tank_REF.gc
@@ -0,0 +1,1934 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; failed to figure out what this is:
+(defpartgroup group-atoll-tank-a-trail
+  :id 318
+  :duration (seconds 0.017)
+  :bounds (static-bspherem 0 0 0 15)
+  :parts ((sp-item 1348) (sp-item 1349))
+  )
+
+;; failed to figure out what this is:
+(defpart 1348
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 4.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 2) (meters 1) 1.0)
+    (sp-rnd-int-flt spt-rot-z (degrees 0.0) 1 32768.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 128.0 64.0 1.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 24.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.013333334) (meters 0.053333335) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.016666668) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-rnd-flt spt-fade-a -0.032 -0.032 1.0)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 2000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (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)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 0.6) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1349
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 4.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 2) (meters 1) 1.0)
+    (sp-rnd-int-flt spt-rot-z (degrees 0.0) 1 32768.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-rnd-flt spt-a 8.0 24.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.013333334) (meters 0.053333335) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.016666668) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-rnd-flt spt-fade-a -0.032 -0.032 1.0)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 2000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (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)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 0.6) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpartgroup group-atoll-tank-a-ground
+  :id 319
+  :duration (seconds 0.017)
+  :bounds (static-bspherem 0 0 0 15)
+  :parts ((sp-item 1350) (sp-item 1351))
+  )
+
+;; failed to figure out what this is:
+(defpart 1350
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 4.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 2) (meters 1) 1.0)
+    (sp-rnd-int-flt spt-rot-z (degrees 0.0) 1 32768.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 128.0 64.0 1.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 24.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.013333334) (meters 0.053333335) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.016666668) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-rnd-flt spt-fade-a -0.032 -0.032 1.0)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 2000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-conerot-x (degrees 80.0) (degrees 10.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 0.6) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1351
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 4.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 2) (meters 1) 1.0)
+    (sp-rnd-int-flt spt-rot-z (degrees 0.0) 1 32768.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-rnd-flt spt-a 8.0 24.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.013333334) (meters 0.053333335) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.016666668) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-rnd-flt spt-fade-a -0.032 -0.032 1.0)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 2000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-conerot-x (degrees 80.0) (degrees 10.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 0.6) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpartgroup group-atoll-tank-a-slide
+  :id 320
+  :duration (seconds 0.017)
+  :bounds (static-bspherem 0 0 0 15)
+  :parts ((sp-item 1352) (sp-item 1353))
+  )
+
+;; failed to figure out what this is:
+(defpart 1352
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 1.0 2.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.5) (meters 0.5) 1.0)
+    (sp-rnd-int-flt spt-rot-z (degrees 0.0) 1 32768.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 128.0 64.0 1.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 24.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0) (meters 0.026666667) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.01) (meters 0.006666667) 1.0)
+    (sp-rnd-flt spt-scalevel-y (meters 0.0033333334) (meters 0.0033333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.032 -0.032 1.0)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 1000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 90.0))
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 0.6) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1353
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 1.0 2.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.5) (meters 0.5) 1.0)
+    (sp-rnd-int-flt spt-rot-z (degrees 0.0) 1 32768.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 64.0 64.0 1.0)
+    (sp-copy-from-other spt-g -1)
+    (sp-copy-from-other spt-b -1)
+    (sp-rnd-flt spt-a 8.0 24.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0) (meters 0.026666667) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.01) (meters 0.006666667) 1.0)
+    (sp-rnd-flt spt-scalevel-y (meters 0.0033333334) (meters 0.0033333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.032 -0.032 1.0)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 1000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 90.0))
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 0.6) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpartgroup group-atoll-tank-intact
+  :id 321
+  :bounds (static-bspherem 0 8 12 24)
+  :parts ((sp-item 1354 :fade-after (meters 100) :falloff-to (meters 120) :period 1260 :length 75)
+    (sp-item 1354 :fade-after (meters 100) :falloff-to (meters 120) :period 770 :length 96)
+    (sp-item 1354 :fade-after (meters 140) :falloff-to (meters 160) :period 936 :length 60)
+    (sp-item 1355 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1356 :fade-after (meters 100) :falloff-to (meters 120) :period 1380 :length 75)
+    (sp-item 1356 :fade-after (meters 100) :falloff-to (meters 120) :period 669 :length 96)
+    (sp-item 1356 :fade-after (meters 140) :falloff-to (meters 160) :period 1036 :length 60)
+    (sp-item 1357 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1358 :fade-after (meters 100) :falloff-to (meters 120) :period 1335 :length 75)
+    (sp-item 1358 :fade-after (meters 100) :falloff-to (meters 120) :period 795 :length 96)
+    (sp-item 1358 :fade-after (meters 140) :falloff-to (meters 160) :period 1199 :length 60)
+    (sp-item 1359 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1360 :fade-after (meters 100) :falloff-to (meters 120) :period 1458 :length 75)
+    (sp-item 1360 :fade-after (meters 100) :falloff-to (meters 120) :period 1537 :length 96)
+    (sp-item 1360 :fade-after (meters 140) :falloff-to (meters 160) :period 922 :length 60)
+    (sp-item 1361 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1362 :fade-after (meters 100) :falloff-to (meters 120) :period 1458 :length 75)
+    (sp-item 1362 :fade-after (meters 100) :falloff-to (meters 120) :period 1537 :length 96)
+    (sp-item 1362 :fade-after (meters 140) :falloff-to (meters 160) :period 922 :length 60)
+    (sp-item 1363 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1364 :fade-after (meters 80) :falloff-to (meters 100))
+    (sp-item 1365 :fade-after (meters 80) :falloff-to (meters 100))
+    (sp-item 1366 :fade-after (meters 80) :falloff-to (meters 100))
+    (sp-item 1367 :fade-after (meters 80) :falloff-to (meters 100))
+    (sp-item 1368 :fade-after (meters 80) :falloff-to (meters 100))
+    (sp-item 1369 :fade-after (meters 80) :falloff-to (meters 100))
+    (sp-item 1370 :fade-after (meters 80) :falloff-to (meters 100))
+    (sp-item 1371 :fade-after (meters 80) :falloff-to (meters 100))
+    (sp-item 1372 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1373 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1374 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1375 :fade-after (meters 100) :falloff-to (meters 100))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1374
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-rnd-flt spt-num 1.0 3.0 1.0)
+    (sp-flt spt-x (meters -1))
+    (sp-flt spt-y (meters 9.8))
+    (sp-flt spt-z (meters -7))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-omega 6.144)
+    (sp-rnd-flt spt-vel-y (meters 0.13333334) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.21333334 -0.21333334 1.0)
+    (sp-rnd-flt spt-accel-y -13.653334 1.3653333 1.0)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-launchrot-x (degrees -5.0) (degrees 10.0) 1.0)
+    (sp-rnd-flt spt-launchrot-z (degrees -5.0) (degrees 10.0) 1.0)
+    (sp-flt spt-conerot-x (degrees -20.0))
+    (sp-flt spt-conerot-y (degrees 60.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1375
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-rnd-flt spt-num 0.0 1.0 1.0)
+    (sp-flt spt-x (meters -1))
+    (sp-flt spt-y (meters 9.8))
+    (sp-flt spt-z (meters -7))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-omega 6.144)
+    (sp-rnd-flt spt-vel-y (meters 0.1) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.28444445 -0.28444445 1.0)
+    (sp-rnd-flt spt-accel-y -13.653334 1.3653333 1.0)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 450)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-launchrot-x (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-rnd-flt spt-launchrot-z (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-flt spt-conerot-x (degrees -20.0))
+    (sp-flt spt-conerot-y (degrees 60.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1372
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-rnd-flt spt-num 1.0 3.0 1.0)
+    (sp-flt spt-x (meters 2))
+    (sp-flt spt-y (meters 9.4))
+    (sp-flt spt-z (meters 9.2))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-omega 6.144)
+    (sp-rnd-flt spt-vel-y (meters 0.1) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.21333334 -0.21333334 1.0)
+    (sp-rnd-flt spt-accel-y -13.653334 1.3653333 1.0)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-launchrot-x (degrees -5.0) (degrees 10.0) 1.0)
+    (sp-rnd-flt spt-launchrot-z (degrees -5.0) (degrees 10.0) 1.0)
+    (sp-flt spt-conerot-x (degrees 50.000004))
+    (sp-flt spt-conerot-y (degrees 20.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1373
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-rnd-flt spt-num 0.0 1.0 1.0)
+    (sp-flt spt-x (meters 2))
+    (sp-flt spt-y (meters 9.4))
+    (sp-flt spt-z (meters 9.2))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-omega 6.144)
+    (sp-rnd-flt spt-vel-y (meters 0.1) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.28444445 -0.28444445 1.0)
+    (sp-rnd-flt spt-accel-y -13.653334 1.3653333 1.0)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 450)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-launchrot-x (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-rnd-flt spt-launchrot-z (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-flt spt-conerot-x (degrees 50.000004))
+    (sp-flt spt-conerot-y (degrees 20.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1368
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-x (meters 3.5))
+    (sp-flt spt-y (meters 3))
+    (sp-flt spt-z (meters -3.1))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-omega 4.096)
+    (sp-rnd-flt spt-vel-y (meters 0.06666667) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-accel-y -4.7786665 1.0922667 1.0)
+    (sp-flt spt-friction 0.98)
+    (sp-int spt-timer 40)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-flt spt-conerot-x (degrees 150.0))
+    (sp-flt spt-conerot-y (degrees 120.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1369
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-rnd-flt spt-num 0.0 1.0 1.0)
+    (sp-flt spt-x (meters 3.75))
+    (sp-flt spt-y (meters 2.75))
+    (sp-flt spt-z (meters -3.1))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-rnd-flt spt-a 64.0 32.0 1.0)
+    (sp-flt spt-omega 4.096)
+    (sp-rnd-flt spt-vel-y (meters 0.06666667) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.48 -0.48 1.0)
+    (sp-rnd-flt spt-accel-y -4.7786665 1.0922667 1.0)
+    (sp-flt spt-friction 0.98)
+    (sp-int spt-timer 75)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-launchrot-x (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-rnd-flt spt-launchrot-z (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-flt spt-conerot-x (degrees 150.0))
+    (sp-flt spt-conerot-y (degrees 120.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1370
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-x (meters 4.8))
+    (sp-flt spt-y (meters 0))
+    (sp-flt spt-z (meters -3.8))
+    (sp-rnd-flt spt-scale-x (meters 0.075) (meters 0.05) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-rnd-flt spt-a 64.0 64.0 1.0)
+    (sp-flt spt-omega 4.096)
+    (sp-rnd-flt spt-vel-y (meters 0.016666668) (meters 0.033333335) 1.0)
+    (sp-rnd-flt spt-fade-a -0.21333334 -0.21333334 1.0)
+    (sp-rnd-flt spt-accel-y -4.096 -0.68266666 1.0)
+    (sp-flt spt-friction 0.97)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-conerot-x (degrees 0.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 1371
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-flt spt-num 4.0)
+    (sp-rnd-flt spt-x (meters 4.8) (meters 0.1) 1.0)
+    (sp-flt spt-y (meters 0))
+    (sp-flt spt-z (meters -3.8))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.05) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-rnd-flt spt-a 64.0 64.0 1.0)
+    (sp-flt spt-omega 4.096)
+    (sp-rnd-flt spt-vel-y (meters 0.016666668) (meters 0.05) 1.0)
+    (sp-flt spt-scalevel-x (meters -0.00016666666))
+    (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 -4.096 -0.68266666 1.0)
+    (sp-flt spt-friction 0.97)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-conerot-x (degrees 20.0) (degrees 60.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 25.000002) (degrees 130.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1364
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-x (meters 4.4))
+    (sp-flt spt-y (meters 5.5))
+    (sp-flt spt-z (meters 0.1))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-omega 4.096)
+    (sp-rnd-flt spt-vel-y (meters 0.06666667) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-accel-y -4.7786665 1.0922667 1.0)
+    (sp-flt spt-friction 0.98)
+    (sp-int spt-timer 110)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-flt spt-conerot-x (degrees 130.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1365
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-rnd-flt spt-num 0.0 1.0 1.0)
+    (sp-flt spt-x (meters 4.9))
+    (sp-flt spt-y (meters 5))
+    (sp-flt spt-z (meters 0.1))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-rnd-flt spt-a 64.0 32.0 1.0)
+    (sp-flt spt-omega 4.096)
+    (sp-rnd-flt spt-vel-y (meters 0.06666667) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.48 -0.48 1.0)
+    (sp-rnd-flt spt-accel-y -4.7786665 1.0922667 1.0)
+    (sp-flt spt-friction 0.98)
+    (sp-int spt-timer 200)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-launchrot-x (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-rnd-flt spt-launchrot-z (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-flt spt-conerot-x (degrees 130.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1366
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-x (meters 9.4))
+    (sp-flt spt-y (meters 0))
+    (sp-flt spt-z (meters 0.1))
+    (sp-rnd-flt spt-scale-x (meters 0.075) (meters 0.05) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-rnd-flt spt-a 64.0 64.0 1.0)
+    (sp-flt spt-omega 4.096)
+    (sp-rnd-flt spt-vel-y (meters 0.016666668) (meters 0.033333335) 1.0)
+    (sp-rnd-flt spt-fade-a -0.21333334 -0.21333334 1.0)
+    (sp-rnd-flt spt-accel-y -4.096 -0.68266666 1.0)
+    (sp-flt spt-friction 0.97)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-conerot-x (degrees 0.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 1367
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-flt spt-num 4.0)
+    (sp-rnd-flt spt-x (meters 9.3) (meters 0.1) 1.0)
+    (sp-flt spt-y (meters 0))
+    (sp-flt spt-z (meters 0.1))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.05) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-rnd-flt spt-a 64.0 64.0 1.0)
+    (sp-flt spt-omega 4.096)
+    (sp-rnd-flt spt-vel-y (meters 0.016666668) (meters 0.05) 1.0)
+    (sp-flt spt-scalevel-x (meters -0.00016666666))
+    (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 -4.096 -0.68266666 1.0)
+    (sp-flt spt-friction 0.97)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 0 224 1)
+    (sp-launcher-by-id spt-next-launcher 1320)
+    (sp-rnd-flt spt-conerot-x (degrees 40.0) (degrees 40.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 45.0) (degrees 90.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1363
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.0 2.0 1.0)
+    (sp-flt spt-x (meters 5.75))
+    (sp-flt spt-y (meters 5.5))
+    (sp-flt spt-z (meters 4.1))
+    (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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 32.0 96.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.02) (meters 0.0033333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.85333335 -0.85333335 1.0)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 20.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1362
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 0.6 1.0)
+    (sp-flt spt-x (meters 5.75))
+    (sp-flt spt-y (meters 5.5))
+    (sp-flt spt-z (meters 4.1))
+    (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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 16.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.053333335) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.16 -0.85333335 1.0)
+    (sp-rnd-flt spt-accel-y 4.096 0.13653333 1.0)
+    (sp-flt spt-friction 0.92)
+    (sp-int spt-timer 300)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 20.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1361
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.0 2.0 1.0)
+    (sp-flt spt-x (meters 6))
+    (sp-flt spt-y (meters 6.5))
+    (sp-flt spt-z (meters -6.1))
+    (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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 32.0 96.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.02) (meters 0.0033333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.85333335 -0.85333335 1.0)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 65.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1360
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 0.6 1.0)
+    (sp-flt spt-x (meters 6))
+    (sp-flt spt-y (meters 6.5))
+    (sp-flt spt-z (meters -6.1))
+    (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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 16.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.053333335) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.16 -0.85333335 1.0)
+    (sp-rnd-flt spt-accel-y 4.096 0.13653333 1.0)
+    (sp-flt spt-friction 0.92)
+    (sp-int spt-timer 300)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 65.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1359
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.0 2.0 1.0)
+    (sp-flt spt-x (meters 6))
+    (sp-flt spt-y (meters 6.25))
+    (sp-flt spt-z (meters -5))
+    (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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 32.0 96.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.02) (meters 0.0033333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.85333335 -0.85333335 1.0)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 135.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1358
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 0.6 1.0)
+    (sp-flt spt-x (meters 6))
+    (sp-flt spt-y (meters 6.25))
+    (sp-flt spt-z (meters -5))
+    (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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 16.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.053333335) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.16 -0.85333335 1.0)
+    (sp-rnd-flt spt-accel-y 4.096 0.13653333 1.0)
+    (sp-flt spt-friction 0.92)
+    (sp-int spt-timer 300)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 135.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1357
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.0 2.0 1.0)
+    (sp-flt spt-x (meters 3.75))
+    (sp-flt spt-y (meters 12.25))
+    (sp-flt spt-z (meters 5))
+    (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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 32.0 96.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.02) (meters 0.0033333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.85333335 -0.85333335 1.0)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees -45.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1356
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 0.6 1.0)
+    (sp-flt spt-x (meters 3.75))
+    (sp-flt spt-y (meters 12.25))
+    (sp-flt spt-z (meters 5))
+    (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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 16.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.053333335) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.16 -0.85333335 1.0)
+    (sp-rnd-flt spt-accel-y 4.096 0.13653333 1.0)
+    (sp-flt spt-friction 0.92)
+    (sp-int spt-timer 300)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees -45.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1355
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.0 2.0 1.0)
+    (sp-flt spt-x (meters 4))
+    (sp-flt spt-y (meters 11.1))
+    (sp-flt spt-z (meters 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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 32.0 96.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.02) (meters 0.0033333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.85333335 -0.85333335 1.0)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 30.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1354
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 0.6 1.0)
+    (sp-flt spt-x (meters 4))
+    (sp-flt spt-y (meters 11.1))
+    (sp-flt spt-z (meters 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-flt spt-r 64.0)
+    (sp-flt spt-g 64.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 16.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.053333335) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.006666667) 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-rnd-flt spt-fade-a -0.16 -0.85333335 1.0)
+    (sp-rnd-flt spt-accel-y 4.096 0.13653333 1.0)
+    (sp-flt spt-friction 0.92)
+    (sp-int spt-timer 300)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-conerot-x (degrees 30.0))
+    (sp-flt spt-conerot-y (degrees 90.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpartgroup group-atoll-tank-aftermath
+  :id 322
+  :bounds (static-bspherem 0 0 0 24)
+  :parts ((sp-item 1376 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1377 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1378 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1379 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1380 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1381 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1382 :fade-after (meters 100) :falloff-to (meters 100))
+    (sp-item 1383 :fade-after (meters 100) :falloff-to (meters 100))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1382
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-rnd-flt spt-num 1.0 3.0 1.0)
+    (sp-flt spt-x (meters -0.5))
+    (sp-flt spt-y (meters 0))
+    (sp-flt spt-z (meters -12))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-omega 6.144)
+    (sp-rnd-flt spt-vel-y (meters 0.13333334) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.21333334 -0.21333334 1.0)
+    (sp-rnd-flt spt-accel-y -13.653334 1.3653333 1.0)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-rnd-flt spt-launchrot-x (degrees -5.0) (degrees 10.0) 1.0)
+    (sp-rnd-flt spt-launchrot-z (degrees -5.0) (degrees 10.0) 1.0)
+    (sp-flt spt-conerot-x (degrees -20.0))
+    (sp-flt spt-conerot-y (degrees 60.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1383
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-rnd-flt spt-num 0.0 1.0 1.0)
+    (sp-flt spt-x (meters -0.5))
+    (sp-flt spt-y (meters 0))
+    (sp-flt spt-z (meters -12))
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-omega 6.144)
+    (sp-rnd-flt spt-vel-y (meters 0.1) (meters 0.013333334) 1.0)
+    (sp-rnd-flt spt-fade-a -0.28444445 -0.28444445 1.0)
+    (sp-rnd-flt spt-accel-y -13.653334 1.3653333 1.0)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 450)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-rnd-flt spt-launchrot-x (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-rnd-flt spt-launchrot-z (degrees -30.0) (degrees 60.0) 1.0)
+    (sp-flt spt-conerot-x (degrees -20.0))
+    (sp-flt spt-conerot-y (degrees 60.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1381
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 0.4)
+    (sp-rnd-flt spt-x (meters 18) (meters -1) 1.0)
+    (sp-flt spt-y (meters 0))
+    (sp-rnd-flt spt-z (meters -4) (meters -1) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (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-flt spt-r 192.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.01) (meters 0.01) 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-r -0.64)
+    (sp-flt spt-fade-g -0.32)
+    (sp-flt spt-fade-b -0.32)
+    (sp-rnd-flt spt-fade-a -0.10666667 -0.10666667 1.0)
+    (sp-flt spt-accel-y -0.027306668)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 sp-cpuinfo-flag-14)
+    (sp-int-plain-rnd spt-next-time 150 49 1)
+    (sp-launcher-by-id spt-next-launcher 1384)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1380
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 0.4)
+    (sp-rnd-flt spt-x (meters 16.5) (meters -1) 1.0)
+    (sp-flt spt-y (meters 2.5))
+    (sp-rnd-flt spt-z (meters -9) (meters -1) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (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-flt spt-r 192.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.006666667) (meters 0.006666667) 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-r -0.64)
+    (sp-flt spt-fade-g -0.32)
+    (sp-flt spt-fade-b -0.32)
+    (sp-rnd-flt spt-fade-a -0.16 -0.16 1.0)
+    (sp-flt spt-accel-y -0.027306668)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 400)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 sp-cpuinfo-flag-14)
+    (sp-int-plain-rnd spt-next-time 150 49 1)
+    (sp-launcher-by-id spt-next-launcher 1384)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1379
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 0.4)
+    (sp-rnd-flt spt-x (meters 12) (meters -1) 1.0)
+    (sp-flt spt-y (meters 2))
+    (sp-rnd-flt spt-z (meters -8) (meters -1) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (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-flt spt-r 192.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.01) (meters 0.01) 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-r -0.64)
+    (sp-flt spt-fade-g -0.32)
+    (sp-flt spt-fade-b -0.32)
+    (sp-rnd-flt spt-fade-a -0.10666667 -0.10666667 1.0)
+    (sp-flt spt-accel-y -0.027306668)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 sp-cpuinfo-flag-14)
+    (sp-int-plain-rnd spt-next-time 150 49 1)
+    (sp-launcher-by-id spt-next-launcher 1384)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1378
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 0.4)
+    (sp-rnd-flt spt-x (meters -1) (meters -1) 1.0)
+    (sp-flt spt-y (meters 0))
+    (sp-rnd-flt spt-z (meters 4) (meters -1) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (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-flt spt-r 192.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.006666667) (meters 0.006666667) 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-r -0.64)
+    (sp-flt spt-fade-g -0.32)
+    (sp-flt spt-fade-b -0.32)
+    (sp-rnd-flt spt-fade-a -0.16 -0.16 1.0)
+    (sp-flt spt-accel-y -0.027306668)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 400)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 sp-cpuinfo-flag-14)
+    (sp-int-plain-rnd spt-next-time 150 49 1)
+    (sp-launcher-by-id spt-next-launcher 1384)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1377
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 0.4)
+    (sp-rnd-flt spt-x (meters 1) (meters -2) 1.0)
+    (sp-flt spt-y (meters 2))
+    (sp-rnd-flt spt-z (meters -9) (meters -2) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 3) (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-flt spt-r 192.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.01) (meters 0.01) 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-r -0.64)
+    (sp-flt spt-fade-g -0.32)
+    (sp-flt spt-fade-b -0.32)
+    (sp-rnd-flt spt-fade-a -0.16 -0.16 1.0)
+    (sp-flt spt-accel-y -0.027306668)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 400)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 sp-cpuinfo-flag-14)
+    (sp-int-plain-rnd spt-next-time 150 49 1)
+    (sp-launcher-by-id spt-next-launcher 1384)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1376
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 0.4)
+    (sp-rnd-flt spt-x (meters 0) (meters -1) 1.0)
+    (sp-flt spt-y (meters 0))
+    (sp-rnd-flt spt-z (meters -1) (meters -1) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (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-flt spt-r 192.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.01) (meters 0.01) 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-r -0.64)
+    (sp-flt spt-fade-g -0.32)
+    (sp-flt spt-fade-b -0.32)
+    (sp-rnd-flt spt-fade-a -0.10666667 -0.10666667 1.0)
+    (sp-flt spt-accel-y -0.027306668)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 sp-cpuinfo-flag-14)
+    (sp-int-plain-rnd spt-next-time 150 49 1)
+    (sp-launcher-by-id spt-next-launcher 1384)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1384
+  :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:
+(defpartgroup group-atoll-tank-explosion
+  :id 323
+  :duration (seconds 0.5)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 32)
+  :parts ((sp-item 1385 :fade-after (meters 200) :falloff-to (meters 200) :period 900 :length 25)
+    (sp-item 1386 :period 900 :length 10 :offset 10)
+    (sp-item 1387 :fade-after (meters 120) :falloff-to (meters 120) :period 900 :length 100 :offset 25)
+    (sp-item 1388 :period 900 :length 160)
+    (sp-item 1388 :period 900 :length 100)
+    (sp-item 1388 :period 900 :length 50)
+    (sp-item 1388 :period 900 :length 40)
+    (sp-item 1388 :period 900 :length 30)
+    (sp-item 1388 :period 900 :length 20)
+    (sp-item 1389 :period 900 :length 50 :offset 15)
+    (sp-item 1390 :period 900 :length 5)
+    (sp-item 1391 :period 900 :length 50 :offset 15)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1388
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-flt spt-num 16.0)
+    (sp-rnd-flt spt-x (meters -2) (meters 4) 1.0)
+    (sp-rnd-flt spt-y (meters -4.5) (meters 5) 1.0)
+    (sp-rnd-flt spt-z (meters -2) (meters 4) 1.0)
+    (sp-flt spt-scale-x (meters 2.5))
+    (sp-int spt-rot-x 4)
+    (sp-rnd-flt spt-scale-y (meters 0.1) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-r 32.0 32.0 1.0)
+    (sp-rnd-flt spt-g 32.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.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.13333334) (meters 0.06666667) 1.0)
+    (sp-rnd-flt spt-accel-y -13.653334 -1.3653333 1.0)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-rnd-flt spt-conerot-x (degrees 20.0) (degrees 70.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 45.0) (degrees 90.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 10) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1391
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x34 :page #xc))
+    (sp-rnd-flt spt-num 5.0 5.0 1.0)
+    (sp-flt spt-y (meters -2.5))
+    (sp-rnd-flt spt-scale-x (meters 3) (meters 2) 1.0)
+    (sp-int spt-rot-x 4)
+    (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 8) (meters 4) 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 0.0 32.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.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-rnd-flt spt-friction 0.89 0.02 1.0)
+    (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 30 9 1)
+    (sp-launcher-by-id spt-next-launcher 1392)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-conerot-x)
+      :flags (sp-flag from-pointer)
+      :func '*sp-temp*
+      )
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 2) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1389
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x33 :page #xc))
+    (sp-rnd-flt spt-num 7.0 10.0 1.0)
+    (sp-flt spt-y (meters -2.5))
+    (sp-rnd-flt spt-scale-x (meters 3) (meters 2) 1.0)
+    (sp-flt spt-rot-z (degrees 0.0))
+    (sp-rnd-flt spt-scale-y (meters 6.8) (meters 1.2) 1.0)
+    (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) (meters 0.13333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.06666667) (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.94)
+    (sp-int spt-timer 1000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int-plain-rnd spt-next-time 30 9 1)
+    (sp-launcher-by-id spt-next-launcher 1392)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 8) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1392
+  :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 1393)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1393
+  :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 1394)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1394
+  :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 1395)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1395
+  :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 1390
+  :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 -2.5))
+    (sp-flt spt-scale-x (meters 32))
+    (sp-flt spt-rot-x 4096.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 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 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 1396)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1396
+  :init-specs ((sp-flt spt-scalevel-x (meters -0.2857143))
+    (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 1387
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x32 :page #xc))
+    (sp-rnd-flt spt-num 6.0 8.0 1.0)
+    (sp-flt spt-x (meters 0.25))
+    (sp-flt spt-y (meters -2.5))
+    (sp-rnd-flt spt-scale-x (meters 3) (meters 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-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.13333334) (meters 0.26666668) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.008333334) (meters 0.0033333334) 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 -1.3653333 -4.096 1.0)
+    (sp-rnd-flt spt-friction 0.88 0.02 1.0)
+    (sp-int spt-timer 3000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int-plain-rnd spt-next-time 35 14 1)
+    (sp-launcher-by-id spt-next-launcher 1397)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 3) (meters 5) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1397
+  :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 1398)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1398
+  :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 1385
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 4.0 8.0 1.0)
+    (sp-rnd-flt spt-x (meters 0) (meters 0.6) 1.0)
+    (sp-flt spt-y (meters -2.5))
+    (sp-rnd-flt spt-scale-x (meters 8.5) (meters 8) 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.2) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.033333335) (meters 0.086666666) 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.89)
+    (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 1399)
+    (sp-rnd-flt spt-conerot-x (degrees -1440.0) (degrees 2880.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1399
+  :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 1400)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1400
+  :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 1386
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x31 :page #xc))
+    (sp-flt spt-num 9.0)
+    (sp-flt spt-y (meters -2.5))
+    (sp-rnd-flt spt-scale-x (meters 2) (meters 6) 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.5) (meters 0.5) 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.1) (meters 0.2) 1.0)
+    (sp-flt spt-fade-g 0.4)
+    (sp-flt spt-fade-b 0.8)
+    (sp-flt spt-fade-a -0.512)
+    (sp-int spt-timer 250)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int spt-next-time 180)
+    (sp-launcher-by-id spt-next-launcher 1401)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1401
+  :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:
+(defpartgroup group-atoll-tank-splash
+  :id 324
+  :flags (screen-space)
+  :bounds (static-bspherem 0 0 0 16)
+  :parts ((sp-item 1406 :binding 1402)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1402 :flags (start-dead launch-asap) :binding 1403)
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1403 :flags (start-dead launch-asap))
+    (sp-item 1407 :binding 1404)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1404 :flags (start-dead launch-asap) :binding 1405)
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    (sp-item 1405 :flags (start-dead launch-asap))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1407
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x29 :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-x (meters -4.5) (meters 9) 1.0)
+    (sp-rnd-flt spt-y (meters -3) (meters 6) 1.0)
+    (sp-flt spt-scale-x (meters 2.5))
+    (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 128.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (sp-flt spt-a 24.0)
+    (sp-flt spt-scalevel-x (meters 0.16666667))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -1.6)
+    (sp-int spt-timer 10)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-14)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1404
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-scale-x (meters 1.5))
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 128.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 255.0)
+    (sp-flt spt-a 20.0)
+    (sp-flt spt-scalevel-x (meters 0.033333335))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -0.8)
+    (sp-flt spt-accel-y -2.7306666)
+    (sp-int spt-timer 270)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-14)
+    (sp-int spt-next-time 15)
+    (sp-launcher-by-id spt-next-launcher 1408)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1408
+  :init-specs ((sp-flt spt-scalevel-x (meters 0.004166667))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -0.06666667)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1405
+  :init-specs ((sp-flt spt-num 1.0)
+    (sp-int spt-rot-x 12)
+    (sp-flt spt-r 4096.0)
+    (sp-flt spt-g 3276.8)
+    (sp-flt spt-b 3276.8)
+    (sp-flt spt-fade-r 6.068148)
+    (sp-flt spt-fade-g 68.26667)
+    (sp-flt spt-fade-b 3.034074)
+    (sp-flt spt-accel-y -2.7306666)
+    (sp-int spt-timer 270)
+    (sp-cpuinfo-flags distort)
+    (sp-int spt-next-time 30)
+    (sp-launcher-by-id spt-next-launcher 1409)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1409
+  :init-specs ((sp-flt spt-fade-g -5.1200004))
+  )
+
+;; failed to figure out what this is:
+(defpart 1406
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x29 :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-x (meters -4.5) (meters 9) 1.0)
+    (sp-rnd-flt spt-y (meters -3) (meters 6) 1.0)
+    (sp-flt spt-scale-x (meters 4))
+    (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 128.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (sp-flt spt-a 24.0)
+    (sp-flt spt-scalevel-x (meters 0.26666668))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -1.6)
+    (sp-int spt-timer 10)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-14)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1402
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x21 :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-scale-x (meters 2.6))
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 128.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 255.0)
+    (sp-flt spt-a 20.0)
+    (sp-flt spt-scalevel-x (meters 0.06666667))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -0.8)
+    (sp-flt spt-accel-y -2.7306666)
+    (sp-int spt-timer 270)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-14)
+    (sp-int spt-next-time 15)
+    (sp-launcher-by-id spt-next-launcher 1410)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1410
+  :init-specs ((sp-flt spt-scalevel-x (meters 0.008333334))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -0.06666667)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1403
+  :init-specs ((sp-flt spt-num 1.0)
+    (sp-int spt-rot-x 24)
+    (sp-flt spt-r 12288.0)
+    (sp-flt spt-g 6553.6)
+    (sp-flt spt-b 6553.6)
+    (sp-flt spt-fade-r 12.136296)
+    (sp-flt spt-fade-g 136.53334)
+    (sp-flt spt-fade-b 6.068148)
+    (sp-flt spt-accel-y -2.7306666)
+    (sp-int spt-timer 270)
+    (sp-cpuinfo-flags distort)
+    (sp-int spt-next-time 30)
+    (sp-launcher-by-id spt-next-launcher 1411)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 1411
+  :init-specs ((sp-flt spt-fade-g -10.240001))
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-atoll-tank-a-debris atoll-tank atoll-tank-a-lod0-jg -1
+              ((atoll-tank-a-lod0-mg (meters 999999)))
+              :bounds (static-spherem 30 -15 13 57)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-atoll-tank-b-debris atoll-tank atoll-tank-b-lod0-jg -1
+              ((atoll-tank-b-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -10 -5 32)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-atoll-tank-c-debris atoll-tank atoll-tank-c-lod0-jg -1
+              ((atoll-tank-c-lod0-mg (meters 999999)))
+              :bounds (static-spherem 30 -15 26 66)
+              )
+
+;; definition of type atoll-tank
+(deftype atoll-tank (process-focusable)
+  ((is-master?     symbol                    :offset-assert 204)
+   (aftermath-part sparticle-launch-control  :offset-assert 208)
+   )
+  :heap-base #x60
+  :method-count-assert 29
+  :size-assert         #xd4
+  :flag-assert         #x1d006000d4
+  (:methods
+    (dormant () _type_ :state 27)
+    (idle () _type_ :state 28)
+    )
+  )
+
+;; definition for method 3 of type atoll-tank
+(defmethod inspect atoll-tank ((obj atoll-tank))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-focusable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tis-master?: ~A~%" (-> obj is-master?))
+  (format #t "~2Taftermath-part: ~A~%" (-> obj aftermath-part))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for method 10 of type atoll-tank
+(defmethod deactivate atoll-tank ((obj atoll-tank))
+  (if (nonzero? (-> obj aftermath-part))
+      (kill-and-free-particles (-> obj aftermath-part))
+      )
+  ((method-of-type process-focusable deactivate) obj)
+  (none)
+  )
+
+;; definition for method 7 of type atoll-tank
+;; WARN: Return type mismatch process-focusable vs atoll-tank.
+(defmethod relocate atoll-tank ((obj atoll-tank) (arg0 int))
+  (if (nonzero? (-> obj aftermath-part))
+      (&+! (-> obj aftermath-part) arg0)
+      )
+  (the-as atoll-tank ((method-of-type process-focusable relocate) obj arg0))
+  )
+
+;; definition for method 12 of type atoll-tank
+(defmethod run-logic? atoll-tank ((obj atoll-tank))
+  #t
+  )
+
+;; definition for method 20 of type atoll-tank
+;; INFO: Used lq/sq
+(defmethod get-trans atoll-tank ((obj atoll-tank) (arg0 int))
+  "@returns the `trans` [[vector]] from the process's `root` (typically either a [[trsqv]] or a [[collide-shape]])"
+  (let ((v1-0 (-> obj root-override)))
+    (case arg0
+      ((3 2)
+       (let ((v0-0 (new 'static 'vector :w 1.0)))
+         (set! (-> v0-0 quad) (-> v1-0 trans quad))
+         (set! (-> v0-0 y) (+ 12288.0 (-> v0-0 y)))
+         v0-0
+         )
+       )
+      (else
+        (-> v1-0 trans)
+        )
+      )
+    )
+  )
+
+;; definition for function atoll-tank-init-by-other
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defbehavior atoll-tank-init-by-other atoll-tank ((arg0 process-drawable) (arg1 int))
+  (set! (-> self is-master?) #f)
+  (set! (-> self root-override) (the-as collide-shape (new 'process 'trsqv)))
+  (let ((s4-0 (-> self root-override)))
+    (set! (-> s4-0 trans quad) (-> arg0 root trans quad))
+    (quaternion-copy! (-> s4-0 quat) (-> arg0 root quat))
+    (vector-identity! (-> s4-0 scale))
+    )
+  (logior! (-> self focus-status) (focus-status ignore))
+  (cond
+    ((= arg1 1)
+     (initialize-skeleton
+       self
+       (the-as
+         skeleton-group
+         (art-group-get-by-name *level* "skel-atoll-tank-b-debris" (the-as (pointer uint32) #f))
+         )
+       (the-as pair 0)
+       )
+     (ja-channel-set! 1)
+     (ja :group! atoll-tank-b-debris-ja :num! min)
+     (setup-masks (-> self draw) 0 2)
+     )
+    (else
+      (initialize-skeleton
+        self
+        (the-as
+          skeleton-group
+          (art-group-get-by-name *level* "skel-atoll-tank-c-debris" (the-as (pointer uint32) #f))
+          )
+        (the-as pair 0)
+        )
+      (ja-channel-set! 1)
+      (ja :group! atoll-tank-c-debris-ja :num! min)
+      (setup-masks (-> self draw) 0 2)
+      )
+    )
+  (ja-post)
+  (go-virtual idle)
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate dormant (atoll-tank)
+  :virtual #t
+  :code (the-as (function none :behavior atoll-tank) sleep-code)
+  )
+
+;; failed to figure out what this is:
+(defstate idle (atoll-tank)
+  :virtual #t
+  :trans (behavior ()
+    (if (-> self is-master?)
+        (spawn (-> self aftermath-part) (-> self root-override trans))
+        )
+    (none)
+    )
+  :code (behavior ()
+    (when (-> self is-master?)
+      (process-spawn atoll-tank self 1 :to self)
+      (process-spawn atoll-tank self 2 :to self)
+      )
+    (sleep-code)
+    (none)
+    )
+  )
+
+;; definition for method 11 of type atoll-tank
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! atoll-tank ((obj atoll-tank) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (set! (-> obj is-master?) #t)
+  (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 9) 0)))
+      (set! (-> s4-0 total-prims) (the-as uint 10))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> s3-0 prim-core action) (collide-action solid))
+      (set! (-> s3-0 transform-index) 2)
+      (set-vector! (-> s3-0 local-sphere) 163840.0 0.0 102400.0 278528.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (let ((v1-9 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-9 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-9 prim-core action) (collide-action solid))
+      (set! (-> v1-9 transform-index) 2)
+      (set-vector! (-> v1-9 local-sphere) 4096.0 0.0 -24576.0 59392.0)
+      )
+    (let ((v1-11 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-11 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-11 prim-core action) (collide-action solid))
+      (set! (-> v1-11 transform-index) 2)
+      (set-vector! (-> v1-11 local-sphere) 55296.0 1228.8 -28672.0 34816.0)
+      )
+    (let ((v1-13 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 2) (the-as uint 0))))
+      (set! (-> v1-13 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-13 prim-core action) (collide-action solid))
+      (set! (-> v1-13 transform-index) 2)
+      (set-vector! (-> v1-13 local-sphere) 131072.0 0.0 20480.0 57344.0)
+      )
+    (let ((v1-15 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 3) (the-as uint 0))))
+      (set! (-> v1-15 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-15 prim-core action) (collide-action solid))
+      (set! (-> v1-15 transform-index) 2)
+      (set-vector! (-> v1-15 local-sphere) 221184.0 -45056.0 303104.0 40960.0)
+      )
+    (let ((v1-17 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 4) (the-as uint 0))))
+      (set! (-> v1-17 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-17 prim-core action) (collide-action solid))
+      (set! (-> v1-17 transform-index) 2)
+      (set-vector! (-> v1-17 local-sphere) 204800.0 -57344.0 40960.0 12288.0)
+      )
+    (let ((v1-19 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 5) (the-as uint 0))))
+      (set! (-> v1-19 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-19 prim-core action) (collide-action solid))
+      (set! (-> v1-19 transform-index) 2)
+      (set-vector! (-> v1-19 local-sphere) 280576.0 -57344.0 133120.0 24576.0)
+      )
+    (let ((v1-21 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 6) (the-as uint 0))))
+      (set! (-> v1-21 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-21 prim-core action) (collide-action solid))
+      (set! (-> v1-21 transform-index) 2)
+      (set-vector! (-> v1-21 local-sphere) 194560.0 -57344.0 155648.0 32768.0)
+      )
+    (let ((v1-23 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 7) (the-as uint 0))))
+      (set! (-> v1-23 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-23 prim-core action) (collide-action solid))
+      (set! (-> v1-23 transform-index) 2)
+      (set-vector! (-> v1-23 local-sphere) 73728.0 -57344.0 81920.0 32768.0)
+      )
+    (let ((v1-25 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 8) (the-as uint 0))))
+      (set! (-> v1-25 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-25 prim-core action) (collide-action solid))
+      (set! (-> v1-25 transform-index) 2)
+      (set-vector! (-> v1-25 local-sphere) -28672.0 -57344.0 86016.0 34816.0)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-28 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-28 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-28 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-atoll-tank-a-debris" (the-as (pointer uint32) #f))
+      )
+    (the-as pair 0)
+    )
+  (logior! (-> obj focus-status) (focus-status ignore))
+  (ja-channel-set! 1)
+  (let ((s5-2 (-> obj skel root-channel 0)))
+    (joint-control-channel-group-eval!
+      s5-2
+      (the-as art-joint-anim (-> obj draw art-group data 2))
+      num-func-identity
+      )
+    (set! (-> s5-2 frame-num) 0.0)
+    )
+  (transform-post)
+  (setup-masks (-> obj draw) 0 2)
+  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 321) obj))
+  (set! (-> obj aftermath-part) (create-launch-control (-> *part-group-id-table* 322) obj))
+  (cond
+    ((task-node-closed? (game-task-node atoll-sig-tank))
+     (go (method-of-object obj idle))
+     )
+    (else
+      (logior! (-> obj draw status) (draw-control-status no-draw))
+      (let ((v1-54 (-> obj root-override root-prim)))
+        (set! (-> v1-54 prim-core collide-as) (collide-spec))
+        (set! (-> v1-54 prim-core collide-with) (collide-spec))
+        )
+      (set! (-> obj root-override backup-collide-as) (collide-spec))
+      (set! (-> obj root-override backup-collide-with) (collide-spec))
+      0
+      (go (method-of-object obj dormant))
+      )
+    )
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/atoll/juicer_REF.gc b/test/decompiler/reference/jak2/levels/atoll/juicer_REF.gc
new file mode 100644
index 0000000000..8ce89aca93
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/atoll/juicer_REF.gc
@@ -0,0 +1,1985 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; failed to figure out what this is:
+(defpartgroup group-juicer-shot-hit
+  :id 1061
+  :duration (seconds 0.017)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 8)
+  :parts ((sp-item 4633))
+  )
+
+;; failed to figure out what this is:
+(defpart 4633
+  :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 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 96.0 64.0 1.0)
+    (sp-rnd-flt spt-g 64.0 32.0 1.0)
+    (sp-rnd-flt spt-b 96.0 64.0 1.0)
+    (sp-flt spt-a 64.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-flt spt-fade-r -0.35555556)
+    (sp-flt spt-fade-g -0.35555556)
+    (sp-flt spt-fade-b 0.0)
+    (sp-flt spt-fade-a -0.30476192)
+    (sp-rnd-flt spt-accel-y -0.68266666 0.68266666 1.0)
+    (sp-int spt-timer 210)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int spt-next-time 60)
+    (sp-launcher-by-id spt-next-launcher 4634)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 180.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4635
+  :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 3.5))
+    (sp-flt spt-rot-x 409.6)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 0.0)
+    (sp-flt spt-b 0.0)
+    (sp-flt spt-a 16.0)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 819.2)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4636
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xca :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1.5) (meters 1) 1.0)
+    (sp-flt spt-rot-x 409.6)
+    (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 0.0)
+    (sp-flt spt-b 0.0)
+    (sp-rnd-flt spt-a 48.0 16.0 1.0)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 819.2)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4637
+  :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 1.5) (meters 0.5) 1.0)
+    (sp-flt spt-rot-x 409.6)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 16.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 0.0)
+    (sp-flt spt-b 0.0)
+    (sp-rnd-flt spt-a 16.0 16.0 1.0)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 819.2)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4638
+  :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.2) 1.0)
+    (sp-flt spt-rot-x 409.6)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-rnd-flt spt-g 196.0 128.0 1.0)
+    (sp-rnd-flt spt-b 64.0 64.0 1.0)
+    (sp-rnd-flt spt-a 32.0 16.0 1.0)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 819.2)
+    )
+  )
+
+;; definition of type juicer-shot
+(deftype juicer-shot (projectile)
+  ((lightning lightning-control 5 :offset-assert 472)
+   (victim    handle              :offset-assert 496)
+   )
+  :heap-base #x180
+  :method-count-assert 40
+  :size-assert         #x1f8
+  :flag-assert         #x28018001f8
+  )
+
+;; definition for method 3 of type juicer-shot
+(defmethod inspect juicer-shot ((obj juicer-shot))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type projectile inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tlightning[5] @ #x~X~%" (-> obj lightning))
+  (format #t "~2Tvictim: ~D~%" (-> obj victim))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for method 35 of type juicer-shot
+;; INFO: Used lq/sq
+(defmethod event-handler! juicer-shot ((obj juicer-shot) (arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  "Multiplex the projectile's event processing, called by [[projectile-event-handler]]"
+  (with-pp
+    (case arg2
+      (('reset)
+       (let ((v1-1 (the-as object (-> arg3 param 0))))
+         (set! (-> obj root-override trans quad) (-> (the-as matrix v1-1) trans quad))
+         (set! (-> obj starting-pos quad) (-> (the-as matrix v1-1) trans quad))
+         (set! (-> obj root-override transv quad) (-> (&+ (the-as matrix v1-1) 64) quad 0))
+         (set! (-> obj pre-move-transv quad) (-> (&+ (the-as matrix v1-1) 64) quad 0))
+         )
+       (set! (-> obj hits) 0)
+       (set! (-> obj spawn-time) (-> pp clock frame-counter))
+       (if (made-impact? obj)
+           (go (method-of-object obj impact))
+           (go (method-of-object obj moving))
+           )
+       #t
+       )
+      (else
+        ((method-of-type projectile event-handler!) obj arg0 arg1 arg2 arg3)
+        )
+      )
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate dissipate (juicer-shot)
+  :virtual #t
+  :enter (behavior ()
+    (go-virtual impact)
+    (none)
+    )
+  )
+
+;; definition for method 37 of type juicer-shot
+(defmethod deal-damage! juicer-shot ((obj juicer-shot) (arg0 process) (arg1 event-message-block))
+  "Constructs an [[attack-info]] according to the projectile's `options`"
+  (let ((a0-2 (if (type? arg0 process-focusable)
+                  arg0
+                  )
+              )
+        )
+    (when a0-2
+      (set! (-> obj victim) (process->handle a0-2))
+      #t
+      )
+    )
+  )
+
+;; definition for method 25 of type juicer-shot
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod spawn-impact-particles juicer-shot ((obj juicer-shot))
+  "Spawns associated particles with the projectile if applicable"
+  (let ((s5-0 (-> obj starting-pos))
+        (s4-0 (-> obj root-override trans))
+        )
+    (when (line-in-view-frustum? s5-0 s4-0)
+      (let ((s3-0 (new 'stack-no-clear 'vector))
+            (s2-0 (new 'stack-no-clear 'vector))
+            (s1-0 (new 'stack-no-clear 'matrix))
+            )
+        (let ((t9-1 sp-launch-particles-var)
+              (a0-2 *sp-particle-system-2d*)
+              (a1-1 (-> *part-id-table* 4637))
+              (a2-0 *launch-matrix*)
+              )
+          (set! (-> a2-0 trans quad) (-> s5-0 quad))
+          (t9-1 a0-2 a1-1 a2-0 (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-2 (-> *part-id-table* 4638))
+              (a2-1 *launch-matrix*)
+              )
+          (set! (-> a2-1 trans quad) (-> s5-0 quad))
+          (t9-2 a0-3 a1-2 a2-1 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0)
+          )
+        (when (not (handle->process (-> obj victim)))
+          (let ((t9-3 sp-launch-particles-var)
+                (a0-8 *sp-particle-system-2d*)
+                (a1-4 (-> *part-id-table* 4637))
+                (a2-2 *launch-matrix*)
+                )
+            (set! (-> a2-2 trans quad) (-> s4-0 quad))
+            (t9-3 a0-8 a1-4 a2-2 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0)
+            )
+          (let ((t9-4 sp-launch-particles-var)
+                (a0-9 *sp-particle-system-2d*)
+                (a1-5 (-> *part-id-table* 4638))
+                (a2-3 *launch-matrix*)
+                )
+            (set! (-> a2-3 trans quad) (-> s4-0 quad))
+            (t9-4 a0-9 a1-5 a2-3 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0)
+            )
+          )
+        (vector-! s2-0 s4-0 s5-0)
+        (vector-normalize! s2-0 1.0)
+        (matrix-axis-angle! s1-0 s2-0 13107.2)
+        (vector-reset! (-> s1-0 trans))
+        (set-vector! s3-0 (-> s2-0 z) 0.0 (- (-> s2-0 x)) 1.0)
+        (vector-normalize! s3-0 409.6)
+        (dotimes (s0-0 5)
+          (vector-matrix*! s3-0 s3-0 s1-0)
+          (vector+! s2-0 s3-0 s5-0)
+          (let ((a0-17 (-> obj lightning s0-0))
+                (v1-21 s2-0)
+                )
+            (set! (-> a0-17 state meet data 0 quad) (-> v1-21 quad))
+            )
+          (let ((a0-20 (-> obj lightning s0-0))
+                (v1-25 s4-0)
+                )
+            (set! (-> a0-20 state meet data (+ (the-as int (-> a0-20 state points-to-draw)) -1) quad) (-> v1-25 quad))
+            )
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+;; definition for method 26 of type juicer-shot
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod spawn-shell-particles juicer-shot ((obj juicer-shot))
+  "TODO - confirm"
+  (spawn-impact-particles obj)
+  (let ((s5-0 (get-process *default-dead-pool* part-tracker #x4000)))
+    (when s5-0
+      (let ((t9-2 (method-of-type part-tracker activate)))
+        (t9-2
+          (the-as part-tracker s5-0)
+          *entity-pool*
+          (symbol->string (-> part-tracker symbol))
+          (the-as pointer #x70004000)
+          )
+        )
+      (let ((t9-3 run-function-in-process)
+            (a0-4 s5-0)
+            (a1-2 part-tracker-init)
+            (a2-4 (-> *part-group-id-table* 1061))
+            (a3-1 0)
+            (t0-0 #f)
+            (t1-0 #f)
+            (t2-0 #f)
+            (t3-0 *launch-matrix*)
+            )
+        (set! (-> t3-0 trans quad) (-> obj root-override trans quad))
+        ((the-as (function object object object object object object object object none) t9-3)
+         a0-4
+         a1-2
+         a2-4
+         a3-1
+         t0-0
+         t1-0
+         t2-0
+         t3-0
+         )
+        )
+      (-> s5-0 ppointer)
+      )
+    )
+  0
+  (none)
+  )
+
+;; definition for method 38 of type juicer-shot
+(defmethod made-impact? juicer-shot ((obj juicer-shot))
+  "TODO - queries the collision cache, return true/false"
+  (let ((gp-0 (-> obj root-override))
+        (s5-0 (new 'stack-no-clear 'collide-query))
+        )
+    (let ((v1-0 s5-0))
+      (set! (-> v1-0 radius) (-> gp-0 root-prim prim-core world-sphere w))
+      (set! (-> v1-0 collide-with) (-> gp-0 root-prim prim-core collide-with))
+      (set! (-> v1-0 ignore-process0) obj)
+      (set! (-> v1-0 ignore-process1) (ppointer->process (-> obj parent)))
+      (set! (-> v1-0 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+      (set! (-> v1-0 action-mask) (collide-action solid))
+      )
+    (let ((a0-2 (handle->process (-> obj notify-handle))))
+      (when a0-2
+        (let* ((s4-1 (vector-! (new 'stack-no-clear 'vector) (-> gp-0 trans) (get-trans (the-as process-focusable a0-2) 3)))
+               (f0-2 (- (vector-length s4-1)))
+               )
+          (fill-and-try-snap-to-surface gp-0 s4-1 f0-2 0.0 -3072.0 s5-0)
+          )
+        )
+      )
+    )
+  )
+
+;; definition for function juicer-proj-move
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defbehavior juicer-proj-move juicer ((arg0 juicer-shot))
+  (let ((s5-0 (handle->process (-> arg0 victim))))
+    (cond
+      (s5-0
+        (set! (-> arg0 root-override trans quad) (-> (get-trans (the-as process-focusable s5-0) 3) quad))
+        ((method-of-type projectile deal-damage!) arg0 s5-0 (the-as event-message-block #f))
+        )
+      (else
+        (projectile-move-fill-line-sphere arg0)
+        (if (logtest? (-> arg0 root-override status) (collide-status touch-surface))
+            (go (method-of-object arg0 impact))
+            )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+;; definition for method 30 of type juicer-shot
+;; WARN: Return type mismatch int vs none.
+(defmethod init-collision! juicer-shot ((obj juicer-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) cshape-reaction-default)
+    (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 ((v1-7 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-7 prim-core collide-as) (collide-spec projectile))
+      (set! (-> v1-7 prim-core collide-with)
+            (collide-spec
+              backgnd
+              jak
+              bot
+              crate
+              civilian
+              enemy
+              obstacle
+              vehicle-sphere
+              hit-by-others-list
+              player-list
+              pusher
+              )
+            )
+      (set! (-> v1-7 prim-core action) (collide-action solid))
+      (set-vector! (-> v1-7 local-sphere) 0.0 0.0 0.0 1228.8)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) v1-7)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-10 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-10 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-10 prim-core collide-with))
+      )
+    (set! (-> s5-0 max-iteration-count) (the-as uint 1))
+    (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)
+        )
+  (none)
+  )
+
+;; definition for method 7 of type juicer-shot
+;; WARN: Return type mismatch projectile vs juicer-shot.
+(defmethod relocate juicer-shot ((obj juicer-shot) (arg0 int))
+  (dotimes (v1-0 5)
+    (if (nonzero? (-> obj lightning v1-0))
+        (&+! (-> obj lightning v1-0) arg0)
+        )
+    )
+  (the-as juicer-shot ((method-of-type projectile relocate) obj arg0))
+  )
+
+;; definition for method 31 of type juicer-shot
+;; WARN: Return type mismatch int vs none.
+(defmethod init-proj-settings! juicer-shot ((obj juicer-shot))
+  "Init relevant settings for the [[projectile]] such as gravity, speed, timeout, etc
+:virtual"
+  (logior! (-> obj options) (projectile-options proj-options-8000))
+  (set! (-> obj attack-mode) 'eco-yellow)
+  (set! (-> obj move) juicer-proj-move)
+  (set! (-> obj root-override dynam gravity y) 0.0)
+  (set! (-> obj root-override dynam gravity-length) 0.0)
+  (set! (-> obj root-override dynam gravity-max) 0.0)
+  (set! (-> obj attack-mode) 'shock-red)
+  (dotimes (s5-0 5)
+    (set! (-> obj lightning s5-0) (new
+                                    'process
+                                    'lightning-control
+                                    (new 'static 'lightning-spec
+                                      :name #f
+                                      :flags (lightning-spec-flags lsf0)
+                                      :start-color (new 'static 'rgba :r #x80 :g #x80 :b #x80 :a #x80)
+                                      :end-color (new 'static 'rgba :r #x80 :g #x80 :b #x80 :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 #x86 :page #xc)
+                                      :reduction 0.42
+                                      :num-points 8
+                                      :box-size 8192.0
+                                      :merge-factor 0.5
+                                      :merge-count 2
+                                      :radius 1433.6
+                                      :duration -1.0
+                                      :sound #f
+                                      )
+                                    obj
+                                    0.0
+                                    )
+          )
+    )
+  (set! (-> obj victim) (the-as handle #f))
+  0
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-juicer juicer juicer-lod0-jg -1
+              ((juicer-lod0-mg (meters 20)) (juicer-lod1-mg (meters 40)) (juicer-lod2-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 5.3)
+              :shadow juicer-shadow-mg
+              :origin-joint-index 21
+              )
+
+;; definition of type juicer-anim-info
+(deftype juicer-anim-info (structure)
+  ((anim-index int32  :offset-assert   0)
+   )
+  :method-count-assert 9
+  :size-assert         #x4
+  :flag-assert         #x900000004
+  )
+
+;; definition for method 3 of type juicer-anim-info
+(defmethod inspect juicer-anim-info ((obj juicer-anim-info))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'juicer-anim-info)
+  (format #t "~1Tanim-index: ~D~%" (-> obj anim-index))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type juicer-global-info
+(deftype juicer-global-info (basic)
+  ((prev-yellow-hit int8    :offset-assert   4)
+   (prev-blue-hit   int8    :offset-assert   5)
+   (idle-anim       int32 3 :offset-assert   8)
+   (patrol-anim     int32 2 :offset-assert  20)
+   (notice-anim     int32 2 :offset-assert  28)
+   (charge-anim     int32 2 :offset-assert  36)
+   (knocked-anim    int32 2 :offset-assert  44)
+   (celebrate-anim  int32 2 :offset-assert  52)
+   (yellow-hit-anim int32 4 :offset-assert  60)
+   (blue-hit-anim   int32 6 :offset-assert  76)
+   )
+  :method-count-assert 9
+  :size-assert         #x64
+  :flag-assert         #x900000064
+  )
+
+;; definition for method 3 of type juicer-global-info
+(defmethod inspect juicer-global-info ((obj juicer-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 "~1Tidle-anim[3] @ #x~X~%" (-> obj idle-anim))
+  (format #t "~1Tpatrol-anim[2] @ #x~X~%" (-> obj patrol-anim))
+  (format #t "~1Tnotice-anim[2] @ #x~X~%" (-> obj notice-anim))
+  (format #t "~1Tcharge-anim[2] @ #x~X~%" (-> obj charge-anim))
+  (format #t "~1Tknocked-anim[2] @ #x~X~%" (-> obj knocked-anim))
+  (format #t "~1Tcelebrate-anim[2] @ #x~X~%" (-> obj celebrate-anim))
+  (format #t "~1Tyellow-hit-anim[4] @ #x~X~%" (-> obj yellow-hit-anim))
+  (format #t "~1Tblue-hit-anim[6] @ #x~X~%" (-> obj blue-hit-anim))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type juicer
+(deftype juicer (nav-enemy)
+  ((los                los-control  :inline :offset-assert 608)
+   (intro-path         path-control         :offset-assert 756)
+   (joint              joint-mod            :offset-assert 760)
+   (joint-enable       symbol               :offset-assert 764)
+   (joint-blend        float                :offset-assert 768)
+   (last-fire-time     time-frame           :offset-assert 776)
+   (heading            basic                :offset-assert 784)
+   (move-angle         float                :offset-assert 788)
+   (torso-track-player basic                :offset-assert 792)
+   (circle-backward?   symbol               :offset        800)
+   (using-turn-anim    symbol               :offset-assert 804)
+   (hit-focus          enemy-focus          :offset-assert 808)
+   (ambush-path-pt     int8                 :offset-assert 812)
+   (charge-index       int8                 :offset-assert 813)
+   (hostile-dest       vector       :inline :offset-assert 816)
+   (focus-is-up        symbol               :offset-assert 832)
+   (current-projectile handle               :offset-assert 840)
+   )
+  :heap-base #x2d0
+  :method-count-assert 185
+  :size-assert         #x350
+  :flag-assert         #xb902d00350
+  (:methods
+    (ambush-cont () _type_ :state 178)
+    (attack () _type_ :state 179)
+    (juicer-method-180 (_type_) none 180)
+    (fire-projectile (_type_ process-focusable uint) none 181)
+    (juicer-method-182 (_type_) none 182)
+    (juicer-method-183 (_type_) none 183)
+    (juicer-method-184 (_type_ symbol) none 184)
+    )
+  )
+
+;; definition for method 3 of type juicer
+(defmethod inspect juicer ((obj juicer))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type nav-enemy inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tlos: #<los-control @ #x~X>~%" (-> obj los))
+  (format #t "~2Tintro-path: ~A~%" (-> obj intro-path))
+  (format #t "~2Tjoint: ~A~%" (-> obj joint))
+  (format #t "~2Tjoint-enable: ~A~%" (-> obj joint-enable))
+  (format #t "~2Tjoint-blend: ~f~%" (-> obj joint-blend))
+  (format #t "~2Tlast-fire-time: ~D~%" (-> obj last-fire-time))
+  (format #t "~2Theading: ~A~%" (-> obj heading))
+  (format #t "~2Tmove-angle: ~f~%" (-> obj move-angle))
+  (format #t "~2Ttorso-track-player: ~A~%" (-> obj torso-track-player))
+  (format #t "~2Tcircle-radial-dist: ~f~%" (-> obj desired-angle))
+  (format #t "~2Tcircle-backward?: ~A~%" (-> obj circle-backward?))
+  (format #t "~2Tusing-turn-anim: ~A~%" (-> obj using-turn-anim))
+  (format #t "~2Thit-focus: ~A~%" (-> obj hit-focus))
+  (format #t "~2Tambush-path-pt: ~D~%" (-> obj ambush-path-pt))
+  (format #t "~2Tcharge-index: ~D~%" (-> obj charge-index))
+  (format #t "~2Thostile-dest: #<vector @ #x~X>~%" (-> obj hostile-dest))
+  (format #t "~2Tfocus-is-up: ~A~%" (-> obj focus-is-up))
+  (format #t "~2Tcurrent-projectile: ~D~%" (-> obj current-projectile))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for symbol *juicer-global-info*, type juicer-global-info
+(define *juicer-global-info* (new 'static 'juicer-global-info
+                               :idle-anim (new 'static 'array int32 3 5 6 7)
+                               :patrol-anim (new 'static 'array int32 2 8 23)
+                               :notice-anim (new 'static 'array int32 2 21 22)
+                               :charge-anim (new 'static 'array int32 2 9 20)
+                               :knocked-anim (new 'static 'array int32 2 16 18)
+                               :celebrate-anim (new 'static 'array int32 2 24 25)
+                               :yellow-hit-anim (new 'static 'array int32 4 33 34 35 36)
+                               :blue-hit-anim (new 'static 'array int32 6 26 27 28 29 30 31)
+                               )
+        )
+
+;; definition for symbol *juicer-nav-enemy-info*, type nav-enemy-info
+(define *juicer-nav-enemy-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #t
+    :use-victory #t
+    :use-jump-blocked #t
+    :debug-draw-neck #f
+    :jump-debug-draw #f
+    :move-to-ground #t
+    :hover-if-no-ground #f
+    :idle-anim-script (new 'static 'array idle-control-frame 4
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x5 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 5
+    :notice-anim 21
+    :hostile-anim 9
+    :hit-anim 11
+    :knocked-anim 18
+    :knocked-land-anim 19
+    :die-anim 40
+    :die-falling-anim 41
+    :victory-anim 24
+    :jump-wind-up-anim 37
+    :jump-in-air-anim 38
+    :jump-land-anim 39
+    :neck-joint 34
+    :look-at-joint 34
+    :bullseye-joint 6
+    :sound-hit (static-sound-name "juicer-hit")
+    :sound-die (static-sound-name "juicer-die")
+    :notice-distance (meters 30)
+    :notice-distance-delta (meters 10)
+    :proximity-notice-distance (meters 24)
+    :default-hit-points 9
+    :gnd-collide-with (collide-spec backgnd)
+    :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.9
+    :attack-shove-back (meters 3)
+    :attack-shove-up (meters 2)
+    :attack-mode 'shock-red
+    :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 65536.0
+    :knocked-soft-vxz-hi 94208.0
+    :knocked-soft-vy-lo 77824.0
+    :knocked-soft-vy-hi 98304.0
+    :knocked-medium-vxz-lo 81920.0
+    :knocked-medium-vxz-hi 98304.0
+    :knocked-medium-vy-lo 81920.0
+    :knocked-medium-vy-hi 122880.0
+    :knocked-hard-vxz-lo 65536.0
+    :knocked-hard-vxz-hi 95846.4
+    :knocked-hard-vy-lo 122880.0
+    :knocked-hard-vy-hi 163840.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 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 98304.0
+    :knocked-red-vy-lo 90112.0
+    :knocked-red-vy-hi 131072.0
+    :knocked-blue-vxz-lo 24576.0
+    :knocked-blue-vxz-hi 32768.0
+    :knocked-blue-vy-lo 24576.0
+    :knocked-blue-vy-hi 73728.0
+    :shadow-size (meters 2)
+    :shadow-max-y (meters 1)
+    :shadow-min-y (meters -1)
+    :shadow-locus-dist (meters 150)
+    :gem-joint 34
+    :gem-seg #x2
+    :gem-no-seg #x4
+    :gem-offset (new 'static 'sphere :y 942.08 :z 40.96 :r 163840.0)
+    :callback-info #f
+    :use-momentum #f
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #t
+    :use-pacing #t
+    :walk-anim 8
+    :turn-anim 10
+    :run-anim 9
+    :taunt-anim -1
+    :run-travel-speed (meters 8)
+    :run-acceleration (meters 8)
+    :run-turning-acceleration (meters 20)
+    :walk-travel-speed (meters 2)
+    :walk-acceleration (meters 2)
+    :walk-turning-acceleration (meters 3)
+    :maximum-rotation-rate (degrees 360.0)
+    :notice-nav-radius (meters 7.5)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 28672.0
+    :circle-dist-hi 53248.0
+    :nav-mesh #f
+    )
+  )
+
+;; failed to figure out what this is:
+(set! (-> *juicer-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+;; definition for method 182 of type juicer
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod juicer-method-182 juicer ((obj juicer))
+  (let ((s3-0 (handle->process (-> obj focus handle))))
+    (when s3-0
+      (let ((s4-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 4)))
+            (s5-0 (new 'stack-no-clear 'vector))
+            )
+        (set! (-> s5-0 quad) (-> (get-trans (the-as process-focusable s3-0) 3) quad))
+        (let ((s3-1
+                (vector-normalize-copy! (new 'stack-no-clear 'vector) (-> obj node-list data 4 bone transform vector 2) 1.0)
+                )
+              )
+          (vector-! s5-0 s5-0 s4-0)
+          (vector-normalize! s5-0 1.0)
+          (quaternion-from-two-vectors-partial! (-> obj joint quat) s3-1 s5-0 (-> obj joint-blend))
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+;; definition for method 183 of type juicer
+;; WARN: Return type mismatch int vs none.
+(defmethod juicer-method-183 juicer ((obj juicer))
+  (with-pp
+    (cond
+      ((-> obj torso-track-player)
+       (set! (-> obj joint-enable) #t)
+       (seek! (-> obj joint-blend) 1.0 (* 2.0 (-> pp clock seconds-per-frame)))
+       (juicer-method-182 obj)
+       )
+      ((-> obj joint-enable)
+       (seek! (-> obj joint-blend) 0.0 (* 4.0 (-> pp clock seconds-per-frame)))
+       (juicer-method-182 obj)
+       (if (= (-> obj joint-blend) 0.0)
+           (set! (-> obj joint-enable) #f)
+           )
+       )
+      )
+    0
+    (none)
+    )
+  )
+
+;; definition for method 55 of type juicer
+(defmethod enemy-method-55 juicer ((obj juicer))
+  (let ((t9-0 (method-of-type nav-enemy enemy-method-55)))
+    (t9-0 obj)
+    )
+  (los-control-method-9 (-> obj los) (the-as process-focusable #f) (the-as vector #f) 2048.0)
+  (juicer-method-183 obj)
+  (none)
+  )
+
+;; definition for method 180 of type juicer
+(defmethod juicer-method-180 juicer ((obj juicer))
+  (if (and (= (-> obj incoming knocked-type) (knocked-type knocked-type-4))
+           (not (and (-> obj next-state) (let ((v1-6 (-> obj next-state name)))
+                                           (or (= v1-6 'knocked) (= v1-6 'jump) (= v1-6 'jump-land))
+                                           )
+                     )
+                )
+           (zero? (get-rand-int obj 3))
+           (let ((f0-0 (vector-vector-distance-squared (-> obj root-override2 trans) (target-pos 0)))
+                 (f1-0 32768.0)
+                 )
+             (>= f0-0 (* f1-0 f1-0))
+             )
+           )
+      (enemy-method-73 obj)
+      (go (method-of-object obj knocked))
+      )
+  (none)
+  )
+
+;; definition for method 74 of type juicer
+(defmethod enemy-method-74 juicer ((obj juicer) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (case arg2
+    (('hit-flinch)
+     (cond
+       ((zero? (-> obj hit-points))
+        (logclear! (-> obj mask) (process-mask actor-pause))
+        (logclear! (-> obj focus-status) (focus-status dangerous))
+        (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice))
+        (logior! (-> obj enemy-flags) (enemy-flag chase-startup))
+        (logior! (-> obj focus-status) (focus-status hit))
+        (if (zero? (-> obj hit-points))
+            (logior! (-> obj focus-status) (focus-status dead))
+            )
+        (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup))
+        (enemy-method-62 obj)
+        (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
+        (process-contact-action arg0)
+        (send-event arg0 'get-attack-count 1)
+        (juicer-method-180 obj)
+        )
+       (else
+         (let ((v1-31 (ja-channel-float! (the-as art-joint-anim (-> obj draw art-group data 11)) 0.0 0.0 0.0)))
+           (when v1-31
+             (set! (-> v1-31 param 0) 1.0)
+             (set! (-> v1-31 param 1) 0.75)
+             (set! (-> v1-31 param 2) 2.0)
+             (set! (-> v1-31 num-func) num-func-interp-play!)
+             )
+           )
+         )
+       )
+     #t
+     )
+    (('hit)
+     (logclear! (-> obj mask) (process-mask actor-pause))
+     (logclear! (-> obj focus-status) (focus-status dangerous))
+     (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice))
+     (logior! (-> obj enemy-flags) (enemy-flag chase-startup))
+     (logior! (-> obj focus-status) (focus-status hit))
+     (if (zero? (-> obj hit-points))
+         (logior! (-> obj focus-status) (focus-status dead))
+         )
+     (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup))
+     (enemy-method-62 obj)
+     (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
+     (process-contact-action arg0)
+     (send-event arg0 'get-attack-count 1)
+     (if (zero? (-> obj hit-points))
+         (juicer-method-180 obj)
+         (go (method-of-object obj hit))
+         )
+     #t
+     )
+    (('instant-death)
+     (when (> (-> obj hit-points) 0)
+       (set! (-> obj hit-points) 0)
+       (set! (-> obj root-override2 penetrated-by) (enemy-method-59 obj))
+       (let ((s4-0 (enemy-method-50 obj (new 'stack-no-clear 'vector))))
+         (vector-z-quaternion! s4-0 (-> obj root-override2 quat))
+         (vector-float*! s4-0 s4-0 -1.0)
+         (vector-normalize! s4-0 1.0)
+         )
+       (logclear! (-> obj mask) (process-mask actor-pause))
+       (logclear! (-> obj focus-status) (focus-status dangerous))
+       (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice))
+       (logior! (-> obj enemy-flags) (enemy-flag chase-startup))
+       (logior! (-> obj focus-status) (focus-status hit))
+       (if (zero? (-> obj hit-points))
+           (logior! (-> obj focus-status) (focus-status dead))
+           )
+       (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup))
+       (enemy-method-62 obj)
+       (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
+       (process-contact-action arg0)
+       (send-event arg0 'get-attack-count 1)
+       (juicer-method-180 obj)
+       )
+     #t
+     )
+    (('notify)
+     (if (and (= (-> arg3 param 0) 'attack) (= (-> arg3 param 1) (handle->process (-> obj focus handle))))
+         (set! (-> obj hit-focus) (the-as enemy-focus #t))
+         )
+     ((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)
+      )
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate active (juicer)
+  :virtual #t
+  :code (behavior ()
+    (let ((v1-2 (ja-group)))
+      (when (or (and v1-2 (or (= v1-2 juicer-charge0-ja) (= v1-2 juicer-charge1-ja)))
+                (let ((v1-8 (ja-group)))
+                  (and v1-8 (or (= v1-8 juicer-patrol0-ja) (= v1-8 juicer-patrol1-ja)))
+                  )
+                )
+        (ja-no-eval :num! (seek!))
+        (while (not (ja-done? 0))
+          (suspend)
+          (ja-eval)
+          )
+        )
+      )
+    (let ((f30-0 (get-rand-float-range self 0.9 1.1)))
+      (until #f
+        (let ((gp-0 (-> self draw art-group data (-> (&-> *juicer-global-info* patrol-anim (get-rand-int self 2)) 0)))
+              (s5-0 (get-rand-int-range self 1 8))
+              )
+          (let ((v1-34 (ja-group)))
+            (if (not (and v1-34 (= v1-34 gp-0)))
+                (ja-channel-push! 1 (seconds 0.2))
+                )
+            )
+          (dotimes (s4-0 s5-0)
+            (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))
+              )
+            )
+          )
+        (when (zero? (get-rand-int self 2))
+          (let ((v1-58 self))
+            (set! (-> v1-58 enemy-flags) (the-as enemy-flag (logclear (-> v1-58 enemy-flags) (enemy-flag enemy-flag36))))
+            (set! (-> v1-58 nav callback-info) *nav-enemy-null-callback-info*)
+            )
+          0
+          (ja-channel-push! 1 (seconds 0.3))
+          (let ((gp-1 0))
+            (until (not (enemy-method-123 self 0.4))
+              (let* ((v1-62 (enemy-method-120 self 3 gp-1))
+                     (a1-16 (-> self draw art-group data (-> *juicer-global-info* idle-anim v1-62)))
+                     )
+                (set! gp-1 (ash 1 v1-62))
+                (ja-no-eval :group! a1-16
+                            :num! (seek! (the float (+ (-> (the-as art-joint-anim a1-16) frames num-frames) -1)) f30-0)
+                            :frame-num 0.0
+                            )
+                )
+              (ja-no-eval :group! (ja-group)
+                          :num! (seek! (the float (+ (-> (ja-group) frames num-frames) -1)) f30-0)
+                          :frame-num 0.0
+                          )
+              (until (ja-done? 0)
+                (suspend)
+                (ja :num! (seek! max f30-0))
+                )
+              )
+            )
+          (let ((v1-102 self))
+            (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-102 enemy-flags)))
+                (set! (-> v1-102 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-102 enemy-flags))))
+                )
+            (set! (-> v1-102 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-102 enemy-flags))))
+            (set! (-> v1-102 nav callback-info) (-> v1-102 enemy-info-override callback-info))
+            )
+          0
+          )
+        )
+      )
+    #f
+    (none)
+    )
+  )
+
+;; definition for method 84 of type juicer
+(defmethod enemy-method-84 juicer ((obj juicer) (arg0 enemy-jump-info))
+  (cond
+    ((logtest? (-> obj fact-info-override enemy-options) (enemy-option user8))
+     (vector-vector-xz-distance (-> arg0 start-pos) (-> arg0 dest-pos))
+     (let ((f0-1 8192.0))
+       (setup-from-to-height! (-> arg0 traj) (-> arg0 start-pos) (-> arg0 dest-pos) f0-1 -4.551111)
+       )
+     )
+    (else
+      ((method-of-type nav-enemy enemy-method-84) obj arg0)
+      )
+    )
+  (none)
+  )
+
+;; definition for method 93 of type juicer
+(defmethod enemy-method-93 juicer ((obj juicer))
+  (case (-> obj jump-why)
+    ((2)
+     (go (method-of-object obj ambush-cont))
+     )
+    (else
+      ((method-of-type nav-enemy enemy-method-93) obj)
+      )
+    )
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate ambush (juicer)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy ambush) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (when (zero? (-> self intro-path))
+      (format 0 "ERROR: ~A has no intro path, skipping ambush~%" (-> self name))
+      (go-virtual notice)
+      )
+    (get-point-in-path! (-> self intro-path) (-> self root-override2 trans) 0.0 'interp)
+    (none)
+    )
+  :code (behavior ()
+    (set! (-> self ambush-path-pt) 1)
+    (until #f
+      (let ((gp-0 (new 'stack-no-clear 'vector)))
+        (get-point-in-path! (-> self intro-path) gp-0 1.0 'interp)
+        (set! (-> self enemy-flags) (the-as enemy-flag (logclear (-> self enemy-flags) (enemy-flag vulnerable))))
+        (let ((a1-1 (new 'stack-no-clear 'event-message-block)))
+          (let ((v1-5 (process->ppointer self)))
+            (set! (-> a1-1 from) v1-5)
+            )
+          (set! (-> a1-1 num-params) 2)
+          (set! (-> a1-1 message) 'jump)
+          (set! (-> a1-1 param 0) (the-as uint 2))
+          (set! (-> a1-1 param 1) (the-as uint gp-0))
+          (send-event-function self a1-1)
+          )
+        )
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate ambush-cont (juicer)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior juicer) enemy-event-handler)
+  :code (behavior ()
+    (let ((a0-0 (-> self intro-path))
+          (v1-1 (+ (-> self ambush-path-pt) 1))
+          )
+      (if (< v1-1 (-> a0-0 curve num-cverts))
+          (set! (-> self ambush-path-pt) v1-1)
+          (enemy-method-72 self)
+          )
+      )
+    (until #f
+      (let ((gp-0 (new 'stack-no-clear 'vector)))
+        (get-point-in-path! (-> self intro-path) gp-0 (the float (-> self ambush-path-pt)) 'interp)
+        (set! (-> self enemy-flags) (the-as enemy-flag (logclear (-> self enemy-flags) (enemy-flag vulnerable))))
+        (let ((a1-1 (new 'stack-no-clear 'event-message-block)))
+          (let ((v1-9 (process->ppointer self)))
+            (set! (-> a1-1 from) v1-9)
+            )
+          (set! (-> a1-1 num-params) 2)
+          (set! (-> a1-1 message) 'jump)
+          (set! (-> a1-1 param 0) (the-as uint 2))
+          (set! (-> a1-1 param 1) (the-as uint gp-0))
+          (send-event-function self a1-1)
+          )
+        )
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate notice (juicer)
+  :virtual #t
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.075))
+    (let ((s5-0 0))
+      (let ((s4-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override2 quat)))
+            (gp-1 (vector-!
+                    (new 'stack-no-clear 'vector)
+                    (get-trans (the-as process-focusable (handle->process (-> self focus handle))) 0)
+                    (-> self root-override2 trans)
+                    )
+                  )
+            )
+        (vector-flatten! gp-1 gp-1 (-> s4-0 vector 1))
+        (vector-normalize! gp-1 1.0)
+        (cond
+          ((< (vector-dot gp-1 (-> s4-0 vector 2)) (cos 8192.0))
+           )
+          (else
+            (set! s5-0 (logior s5-0 1))
+            )
+          )
+        )
+      (let ((f30-1 (get-rand-float-range self 0.8 1.2))
+            (gp-2 (new 'stack-no-clear 'vector))
+            )
+        (let* ((a0-13 (enemy-method-120 self 2 s5-0))
+               (a1-8 (-> self draw art-group data (-> *juicer-global-info* notice-anim a0-13)))
+               )
+          (ja-no-eval :group! a1-8
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim a1-8) frames num-frames) -1)) f30-1)
+                      :frame-num 0.0
+                      )
+          )
+        (until (ja-done? 0)
+          (let ((a1-9 (-> self nav state)))
+            (set! (-> gp-2 quad) (-> a1-9 travel quad))
+            )
+          (seek-toward-heading-vec! (-> self root-override2) gp-2 (-> self nav max-rotation-rate) (seconds 0.02))
+          (suspend)
+          (ja :num! (seek! max f30-1))
+          )
+        )
+      )
+    (enemy-method-72 self)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate victory (juicer)
+  :virtual #t
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.15))
+    (let ((gp-1 (-> self draw art-group data (-> *juicer-global-info* celebrate-anim (get-rand-int self 2))))
+          (f30-0 (get-rand-float-range self 0.9 1.1))
+          )
+      (ja-no-eval :group! gp-1
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-1) frames num-frames) -1)) f30-0)
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      )
+    (enemy-method-72 self)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate hostile (juicer)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy hostile) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self focus-is-up) #f)
+    (none)
+    )
+  :exit (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy hostile) exit)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((v1-2 (ja-group)))
+      (when (and v1-2 (or (= v1-2 juicer-charge0-ja) (= v1-2 juicer-charge1-ja)))
+        (ja-no-eval :num! (seek!))
+        (while (not (ja-done? 0))
+          (suspend)
+          (ja-eval)
+          )
+        )
+      )
+    (let* ((v1-16 (get-rand-int self 2))
+           (gp-0 (-> self draw art-group data (-> *juicer-global-info* charge-anim v1-16)))
+           )
+      (set! (-> self charge-index) v1-16)
+      (let ((v1-19 (ja-group)))
+        (if (not (and v1-19 (= v1-19 gp-0)))
+            (ja-channel-push! 1 (seconds 0.2))
+            )
+        )
+      (set! (-> self skel root-channel 0 frame-group) (the-as art-joint-anim gp-0))
+      )
+    (ja :num-func num-func-identity :frame-num 0.0)
+    (let ((f30-0 (get-rand-float-range self 0.9 1.1)))
+      (until #f
+        (suspend)
+        (ja :num! (loop! f30-0))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (let ((a0-1 (handle->process (-> self focus handle))))
+      (when a0-1
+        (let* ((gp-0 (get-trans (the-as process-focusable a0-1) 1))
+               (f30-0 (vector-vector-xz-distance (-> self root-override2 trans) gp-0))
+               )
+          (cond
+            ((< (- (-> gp-0 y) (-> self root-override2 trans y)) 4096.0)
+             (let ((v1-10 (-> self nav state)))
+               (logclear! (-> v1-10 flags) (nav-state-flag directional-mode))
+               (logior! (-> v1-10 flags) (nav-state-flag target-poly-dirty))
+               (set! (-> v1-10 target-post quad) (-> gp-0 quad))
+               )
+             0
+             (set! (-> self focus-is-up) #f)
+             )
+            ((not (-> self focus-is-up))
+             (let ((s4-0 (new 'stack-no-clear 'vector))
+                   (s5-0 (new 'stack-no-clear 'vector))
+                   )
+               (let ((f28-0 (rand-vu-float-range 0.0 65536.0)))
+                 (set-vector! s4-0 (* 8192.0 (cos f28-0)) 0.0 (* 8192.0 (sin f28-0)) 1.0)
+                 )
+               (vector+! s4-0 s4-0 gp-0)
+               (cloest-point-on-mesh (-> self nav) s4-0 s4-0 (the-as nav-poly #f))
+               (vector-! s5-0 s4-0 gp-0)
+               (set! (-> s5-0 y) 0.0)
+               (vector-normalize! s5-0 30720.0)
+               (vector+! s5-0 s5-0 s4-0)
+               (let ((v1-24 (-> self nav state)))
+                 (logclear! (-> v1-24 flags) (nav-state-flag directional-mode))
+                 (logior! (-> v1-24 flags) (nav-state-flag target-poly-dirty))
+                 (set! (-> v1-24 target-post quad) (-> s5-0 quad))
+                 )
+               )
+             0
+             (set! (-> self focus-is-up) #t)
+             )
+            (else
+              (when (and (or (logtest? (-> self nav state flags) (nav-state-flag blocked))
+                             (logtest? (-> self nav state flags) (nav-state-flag at-target))
+                             )
+                         (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+                         )
+                (if (and (>= (- (-> self clock frame-counter) (-> self last-fire-time)) (rand-vu-int-range (seconds 1) (seconds 2)))
+                         (< 20480.0 f30-0)
+                         )
+                    (go-virtual attack)
+                    (go-virtual circling)
+                    )
+                )
+              )
+            )
+          (if (and (check-los? (-> self los) 0)
+                   (or (>= 11468.8 f30-0)
+                       (and (>= (- (-> self clock frame-counter) (-> self last-fire-time)) (rand-vu-int-range (seconds 5) (seconds 8)))
+                            (>= 53248.0 f30-0)
+                            )
+                       )
+                   )
+              (go-virtual attack)
+              )
+          )
+        )
+      )
+    (nav-enemy-travel-post)
+    (none)
+    )
+  )
+
+;; definition for function juicer-face-player-post
+;; WARN: Return type mismatch int vs none.
+(defbehavior juicer-face-player-post juicer ()
+  (let ((gp-0 (handle->process (-> self focus handle)))
+        (a0-3 self)
+        )
+    (when (and (logtest? (enemy-flag enemy-flag37) (-> a0-3 enemy-flags)) gp-0)
+      (let ((f0-1 (fabs (deg-diff
+                          (quaternion-y-angle (-> self root-override2 quat))
+                          (vector-y-angle (vector-!
+                                            (new 'stack-no-clear 'vector)
+                                            (get-trans (the-as process-focusable gp-0) 0)
+                                            (-> self root-override2 trans)
+                                            )
+                                          )
+                          )
+                        )
+                  )
+            )
+        (cond
+          ((or (< 5461.3335 f0-1) (and (-> self using-turn-anim) (< 910.2222 f0-1)))
+           (set! (-> self using-turn-anim) #t)
+           (seek-to-point-toward-point!
+             (-> self root-override2)
+             (get-trans (the-as process-focusable gp-0) 0)
+             (-> self nav max-rotation-rate)
+             (seconds 0.2)
+             )
+           )
+          (else
+            (set! (-> self using-turn-anim) #f)
+            )
+          )
+        )
+      )
+    )
+  (nav-enemy-simple-post)
+  0
+  (none)
+  )
+
+;; definition for method 181 of type juicer
+;; WARN: Return type mismatch object vs none.
+(defmethod fire-projectile juicer ((obj juicer) (arg0 process-focusable) (arg1 uint))
+  (with-pp
+    (let ((s4-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 20)))
+          (s5-0 (new 'stack-no-clear 'projectile-init-by-other-params))
+          )
+      (when (not (handle->process (-> obj current-projectile)))
+        (set! (-> s5-0 ent) (-> obj entity))
+        (set! (-> s5-0 charge) 1.0)
+        (set! (-> s5-0 options) (projectile-options))
+        (set! (-> s5-0 notify-handle) (process->handle obj))
+        (set! (-> s5-0 owner-handle) (the-as handle #f))
+        (set! (-> s5-0 ignore-handle) (process->handle obj))
+        (set! (-> s5-0 attack-id) arg1)
+        (set! (-> s5-0 timeout) (new 'static 'handle :process #x4b0 :u64 #x4b0))
+        )
+      (vector-normalize! (vector-! (-> s5-0 pos) (get-trans arg0 3) s4-0) 1.0)
+      (vector-float*! (-> s5-0 vel) (-> s5-0 pos) (* 24576.0 (-> pp clock frames-per-second)))
+      (vector+float*! (-> s5-0 pos) s4-0 (-> s5-0 pos) -1024.0)
+      (let ((a0-20 (handle->process (-> obj current-projectile))))
+        (if a0-20
+            (send-event a0-20 'reset s5-0)
+            (set! (-> obj current-projectile)
+                  (ppointer->handle (spawn-projectile juicer-shot s5-0 obj *default-dead-pool*))
+                  )
+            )
+        )
+      )
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate attack (juicer)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior juicer) enemy-event-handler)
+  :enter (behavior ()
+    (let ((v1-1 (-> self nav state))
+          (a0-1 (-> self root-override2 trans))
+          )
+      (logclear! (-> v1-1 flags) (nav-state-flag directional-mode))
+      (logior! (-> v1-1 flags) (nav-state-flag target-poly-dirty))
+      (set! (-> v1-1 target-post quad) (-> a0-1 quad))
+      )
+    0
+    (set! (-> self torso-track-player) (the-as basic #t))
+    (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags)))
+    (set! (-> self hit-focus) #f)
+    (logior! (-> self focus-status) (focus-status dangerous))
+    (let* ((v1-9 *game-info*)
+           (v0-0 (+ (-> v1-9 attack-id) 1))
+           )
+      (set! (-> v1-9 attack-id) v0-0)
+      (set! (-> self attack-id) v0-0)
+      )
+    (none)
+    )
+  :exit (behavior ()
+    (set! (-> self torso-track-player) #f)
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (juicer-method-184 self #f)
+    (set! (-> self last-fire-time) (-> self clock frame-counter))
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (send-event (handle->process (-> self current-projectile)) 'die)
+    (none)
+    )
+  :trans (behavior ()
+    (when (skip-check-los? (-> self los) 90)
+      )
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.1))
+    (ja-no-eval :group! juicer-attack0-start-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim juicer-attack0-start-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (if (< 11.0 (ja-aframe-num 0))
+          (juicer-method-184 self #t)
+          )
+      (suspend)
+      (ja :num! (seek!))
+      )
+    0
+    (let* ((gp-0 #f)
+           (v1-29 *game-info*)
+           (s5-0 (+ (-> v1-29 attack-id) 1))
+           )
+      (set! (-> v1-29 attack-id) s5-0)
+      (let ((s4-0 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) s4-0) (seconds 0.25))
+          (ja-no-eval :group! juicer-attack0-ja
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim juicer-attack0-ja) frames num-frames) -1)))
+                      :frame-num 0.0
+                      )
+          (until (ja-done? 0)
+            (let ((s3-0 (handle->process (-> self focus handle))))
+              (when s3-0
+                (when (< 28672.0
+                         (vector-vector-distance (-> self root-override2 trans) (get-trans (the-as process-focusable s3-0) 0))
+                         )
+                  (fire-projectile self (the-as process-focusable s3-0) s5-0)
+                  (-> self clock frame-counter)
+                  (if (not gp-0)
+                      (set! gp-0 #t)
+                      )
+                  )
+                )
+              )
+            (if (and (logtest? (-> self enemy-flags) (enemy-flag look-at-focus)) (-> self enemy-info-override use-victory))
+                (go-virtual victory)
+                )
+            (b!
+              (not (and (-> self using-turn-anim) (let ((v1-73 (ja-group)))
+                                                    (not (and v1-73 (= v1-73 juicer-attack-turn-ja)))
+                                                    )
+                        )
+                   )
+              cfg-31
+              :delay (empty-form)
+              )
+            (ja-channel-push! 1 (seconds 0.05))
+            (ja :group! juicer-attack-turn-ja)
+            (b! #t cfg-42 :delay (nop!))
+            (label cfg-31)
+            (when (and (not (-> self using-turn-anim)) (let ((v1-84 (ja-group)))
+                                                         (not (and v1-84 (= v1-84 juicer-attack0-ja)))
+                                                         )
+                       )
+              (ja-channel-push! 1 (seconds 0.05))
+              (ja :group! juicer-attack0-ja)
+              )
+            (label cfg-42)
+            (suspend)
+            (ja :num! (seek!))
+            )
+          (send-event (handle->process (-> self current-projectile)) 'die)
+          (let ((a0-37 (handle->process (-> self focus handle))))
+            (when a0-37
+              (if (>= 28672.0
+                      (vector-vector-distance (-> self root-override2 trans) (get-trans (the-as process-focusable a0-37) 0))
+                      )
+                  (go-virtual circling)
+                  )
+              )
+            )
+          (suspend)
+          )
+        )
+      )
+    (if (-> self hit-focus)
+        (go-virtual victory)
+        )
+    (go-hostile self)
+    (none)
+    )
+  :post juicer-face-player-post
+  )
+
+;; failed to figure out what this is:
+(defstate circling (juicer)
+  :virtual #t
+  :code (behavior ()
+    (let ((v1-2 (ja-group)))
+      (when (and v1-2 (or (= v1-2 juicer-charge0-ja) (= v1-2 juicer-charge1-ja)))
+        (ja-no-eval :num! (seek!))
+        (while (not (ja-done? 0))
+          (suspend)
+          (ja-eval)
+          )
+        )
+      )
+    (until #f
+      (let ((v1-15 self))
+        (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-15 enemy-flags)))
+            (set! (-> v1-15 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-15 enemy-flags))))
+            )
+        (set! (-> v1-15 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-15 enemy-flags))))
+        (set! (-> v1-15 nav callback-info) (-> v1-15 enemy-info-override callback-info))
+        )
+      0
+      (let ((v1-18 self))
+        (set! (-> v1-18 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-18 enemy-flags))))
+        )
+      0
+      (nav-enemy-method-166 self)
+      (let* ((v1-23 (get-rand-int self 2))
+             (gp-0 (-> self draw art-group data (-> *juicer-global-info* charge-anim v1-23)))
+             )
+        (set! (-> self charge-index) v1-23)
+        (let ((v1-26 (ja-group)))
+          (if (not (and v1-26 (= v1-26 gp-0)))
+              (ja-channel-push! 1 (seconds 0.15))
+              )
+          )
+        (let ((s5-0 (+ (get-rand-int self 6) 2))
+              (f30-0 (get-rand-float-range self 0.9 1.1))
+              )
+          (while (nonzero? s5-0)
+            (+! s5-0 -1)
+            (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))
+              )
+            )
+          )
+        )
+      (when (< 20480.0 (vector-vector-xz-distance (-> self focus-pos) (-> self root-override2 trans)))
+        (let ((v1-54 self))
+          (set! (-> v1-54 enemy-flags) (the-as enemy-flag (logclear (-> v1-54 enemy-flags) (enemy-flag enemy-flag36))))
+          (set! (-> v1-54 nav callback-info) *nav-enemy-null-callback-info*)
+          )
+        0
+        (let ((v1-57 self))
+          (set! (-> v1-57 enemy-flags) (the-as enemy-flag (logclear (-> v1-57 enemy-flags) (enemy-flag enemy-flag37))))
+          )
+        0
+        (vector-reset! (-> self root-override2 transv))
+        (ja-channel-push! 1 (seconds 0.1))
+        (let ((gp-2 (-> self draw art-group data (-> *juicer-global-info* celebrate-anim (get-rand-int self 2))))
+              (f30-2 (get-rand-float-range self 0.9 1.1))
+              )
+          (ja-no-eval :group! gp-2
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-2) frames num-frames) -1)) f30-2)
+                      :frame-num 0.0
+                      )
+          (until (ja-done? 0)
+            (suspend)
+            (ja :num! (seek! max f30-2))
+            )
+          )
+        )
+      )
+    #f
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate hit (juicer)
+  :virtual #t
+  :code (behavior ()
+    (local-vars (v1-37 enemy-flag) (v1-45 enemy-flag))
+    (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 enemy-info-override hit-anim))
+                  :num! (seek!
+                    (the float
+                         (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override hit-anim)))
+                                frames
+                                num-frames
+                                )
+                            -1
+                            )
+                         )
+                    f30-0
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      )
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (let ((v1-36 (-> self enemy-flags)))
+      (if (logtest? v1-36 (enemy-flag checking-water))
+          (set! v1-37 (logior v1-36 (enemy-flag enable-on-active)))
+          (set! v1-37 (logclear v1-36 (enemy-flag enable-on-active)))
+          )
+      )
+    (set! (-> self enemy-flags) v1-37)
+    (if (logtest? (-> self enemy-flags) (enemy-flag look-at-move-dest))
+        (set! (-> self mask) (logior (process-mask collectable) (-> self mask)))
+        (logclear! (-> self mask) (process-mask collectable))
+        )
+    (let ((v1-44 (-> self enemy-flags)))
+      (if (logtest? (enemy-flag no-initial-move-to-ground) v1-44)
+          (set! v1-45 (logior (enemy-flag check-water-backup) v1-44))
+          (set! v1-45 (logclear v1-44 (enemy-flag check-water-backup)))
+          )
+      )
+    (set! (-> self enemy-flags) v1-45)
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (logclear! (-> self focus-status) (focus-status hit))
+    (go-virtual hostile)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate stare (juicer)
+  :virtual #t
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 1))
+    (let ((f30-0 (get-rand-float-range self 0.9 1.1))
+          (gp-0 (-> self draw art-group data (-> self enemy-info-override idle-anim)))
+          )
+      (until #f
+        (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))
+          )
+        )
+      )
+    #f
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate taunt (juicer)
+  :virtual #t
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.6))
+    (let ((f30-0 (get-rand-float-range self 0.8 1.2)))
+      (let ((gp-0 (get-rand-int-range self 60 210))
+            (s5-0 (-> self clock frame-counter))
+            (f28-0 f30-0)
+            )
+        (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override idle-anim))
+                    :num! (loop! f28-0)
+                    :frame-num 0.0
+                    )
+        (until (>= (- (-> self clock frame-counter) s5-0) gp-0)
+          (suspend)
+          (ja :num! (loop! f28-0))
+          )
+        )
+      (ja-channel-push! 1 (seconds 0.1))
+      (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override taunt-anim))
+                  :num! (seek!
+                    (the float
+                         (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override taunt-anim)))
+                                frames
+                                num-frames
+                                )
+                            -1
+                            )
+                         )
+                    f30-0
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      )
+    (go-virtual stare)
+    (none)
+    )
+  )
+
+;; definition for method 77 of type juicer
+(defmethod enemy-method-77 juicer ((obj juicer) (arg0 (pointer float)))
+  (local-vars (a2-2 int))
+  (case (-> obj incoming knocked-type)
+    (((knocked-type knocked-type-4))
+     (ja-channel-push! 1 0)
+     (let* ((a2-0 (ash 1 (-> *juicer-global-info* prev-yellow-hit)))
+            (v1-3 (enemy-method-120 obj 4 a2-0))
+            (a1-6 (-> obj draw art-group data (-> *juicer-global-info* yellow-hit-anim v1-3)))
+            )
+       (set! (-> *juicer-global-info* prev-yellow-hit) v1-3)
+       (let ((a0-13 (-> obj skel root-channel 0)))
+         (set! (-> a0-13 frame-group) (the-as art-joint-anim a1-6))
+         (set! (-> a0-13 param 0) (the float (+ (-> (the-as art-joint-anim a1-6) frames num-frames) -1)))
+         (set! (-> a0-13 param 1) (-> arg0 0))
+         (set! (-> a0-13 frame-num) 0.0)
+         (joint-control-channel-group! a0-13 (the-as art-joint-anim a1-6) num-func-seek!)
+         )
+       )
+     )
+    (((knocked-type knocked-type-6))
+     (let ((v1-11 (ash 1 (-> *juicer-global-info* prev-blue-hit))))
+       (if (zero? (-> obj charge-index))
+           (set! a2-2 (logior v1-11 56))
+           (set! a2-2 (logior v1-11 7))
+           )
+       )
+     (let* ((v1-15 (enemy-method-120 obj 6 a2-2))
+            (s5-1 (-> obj draw art-group data (-> *juicer-global-info* blue-hit-anim v1-15)))
+            )
+       (set! (-> *juicer-global-info* prev-blue-hit) v1-15)
+       (let ((v1-18 (if (> (-> obj skel active-channels) 0)
+                        (-> obj skel root-channel 0 frame-group)
+                        )
+                    )
+             )
+         (if (and v1-18 (= v1-18 (-> obj draw art-group data 32)))
+             (ja-channel-push! 1 (seconds 0.17))
+             (ja-channel-push! 1 (seconds 0.02))
+             )
+         )
+       (let ((a0-32 (-> obj skel root-channel 0)))
+         (set! (-> a0-32 frame-group) (the-as art-joint-anim s5-1))
+         (set! (-> a0-32 param 0) (the float (+ (-> (the-as art-joint-anim s5-1) frames num-frames) -1)))
+         (set! (-> a0-32 param 1) 1.0)
+         (set! (-> a0-32 frame-num) 0.0)
+         (joint-control-channel-group! a0-32 (the-as art-joint-anim s5-1) num-func-seek!)
+         )
+       )
+     )
+    (else
+      (let ((s4-1 (-> obj draw art-group data (-> *juicer-global-info* knocked-anim (get-rand-int obj 2)))))
+        (ja-channel-push! 1 (seconds 0.17))
+        (let ((a0-37 (-> obj skel root-channel 0)))
+          (set! (-> a0-37 frame-group) (the-as art-joint-anim s4-1))
+          (set! (-> a0-37 param 0) (the float (+ (-> (the-as art-joint-anim s4-1) frames num-frames) -1)))
+          (set! (-> a0-37 param 1) (-> arg0 0))
+          (set! (-> a0-37 frame-num) 0.0)
+          (joint-control-channel-group! a0-37 (the-as art-joint-anim s4-1) num-func-seek!)
+          )
+        )
+      )
+    )
+  #t
+  )
+
+;; definition for method 78 of type juicer
+(defmethod enemy-method-78 juicer ((obj juicer) (arg0 (pointer float)))
+  (cond
+    ((= (-> obj incoming knocked-type) (knocked-type knocked-type-6))
+     (when (>= (-> obj incoming blue-juggle-count) (the-as uint 2))
+       (let ((s4-0 (-> obj draw art-group data 32)))
+         (ja-channel-push! 1 (seconds 0.17))
+         (let ((a0-3 (-> obj skel root-channel 0)))
+           (set! (-> a0-3 frame-group) (the-as art-joint-anim s4-0))
+           (set! (-> a0-3 param 0) (the float (+ (-> (the-as art-joint-anim s4-0) frames num-frames) -1)))
+           (set! (-> a0-3 param 1) (-> arg0 0))
+           (set! (-> a0-3 frame-num) 0.0)
+           (joint-control-channel-group! a0-3 (the-as art-joint-anim s4-0) num-func-seek!)
+           )
+         )
+       #t
+       )
+     )
+    ((!= (-> obj incoming knocked-type) (knocked-type knocked-type-4))
+     (let* ((v1-14 (if (> (-> obj skel active-channels) 0)
+                       (-> obj skel root-channel 0 frame-group)
+                       )
+                   )
+            (s4-1 (if (and v1-14 (= v1-14 (-> obj draw art-group data 18)))
+                      (-> obj draw art-group data 19)
+                      (-> obj draw art-group data 17)
+                      )
+                  )
+            )
+       (ja-channel-push! 1 (seconds 0.17))
+       (let ((a0-10 (-> obj skel root-channel 0)))
+         (set! (-> a0-10 frame-group) (the-as art-joint-anim s4-1))
+         (set! (-> a0-10 param 0) (the float (+ (-> (the-as art-joint-anim s4-1) frames num-frames) -1)))
+         (set! (-> a0-10 param 1) (-> arg0 0))
+         (set! (-> a0-10 frame-num) 0.0)
+         (joint-control-channel-group! a0-10 (the-as art-joint-anim s4-1) num-func-seek!)
+         )
+       )
+     #t
+     )
+    )
+  )
+
+;; definition for method 184 of type juicer
+;; WARN: Return type mismatch symbol vs none.
+(defmethod juicer-method-184 juicer ((obj juicer) (arg0 symbol))
+  (let ((v1-1 (-> obj root-override2 root-prim)))
+    (dotimes (a0-1 (the-as int (-> v1-1 specific 0)))
+      (let ((a2-1 (-> (the-as collide-shape-prim-group v1-1) child a0-1)))
+        (if arg0
+            (logior! (-> a2-1 prim-core action) (collide-action deadly))
+            (logclear! (-> a2-1 prim-core action) (collide-action deadly))
+            )
+        )
+      )
+    )
+  (none)
+  )
+
+;; definition for method 63 of type juicer
+;; WARN: Return type mismatch none vs symbol.
+(defmethod enemy-method-63 juicer ((obj juicer) (arg0 process-focusable) (arg1 symbol))
+  (let ((t9-0 (method-of-type nav-enemy enemy-method-63)))
+    (the-as symbol (if (t9-0 obj arg0 arg1)
+                       (set-dst-proc! (-> obj los) (-> obj focus handle))
+                       )
+            )
+    )
+  )
+
+;; definition for method 114 of type juicer
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-114 juicer ((obj juicer))
+  "@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 6) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 7))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec enemy))
+      (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 deadly no-standon))
+      (set! (-> s4-0 transform-index) 21)
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 -4096.0 18432.0)
+      (set! (-> s5-0 root-prim) s4-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 enemy))
+      (set! (-> v1-14 prim-core collide-with)
+            (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list)
+            )
+      (set! (-> v1-14 prim-core action) (collide-action solid no-standon))
+      (set-vector! (-> v1-14 local-sphere) 0.0 6144.0 0.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 enemy))
+      (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) 6)
+      (set-vector! (-> v1-16 local-sphere) 0.0 0.0 0.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 enemy))
+      (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) 16)
+      (set-vector! (-> v1-18 local-sphere) 0.0 0.0 0.0 2048.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 enemy))
+      (set! (-> v1-20 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-20 prim-core action) (collide-action solid))
+      (set! (-> v1-20 transform-index) 11)
+      (set-vector! (-> v1-20 local-sphere) 0.0 0.0 0.0 2048.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 enemy))
+      (set! (-> v1-22 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-22 prim-core action) (collide-action solid))
+      (set! (-> v1-22 transform-index) 34)
+      (set-vector! (-> v1-22 local-sphere) 0.0 0.0 0.0 2048.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 enemy))
+      (set! (-> v1-24 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-24 prim-core action) (collide-action solid))
+      (set! (-> v1-24 transform-index) 20)
+      (set-vector! (-> v1-24 local-sphere) 0.0 0.0 0.0 2048.0)
+      )
+    (set! (-> s5-0 nav-radius) 8192.0)
+    (let ((v1-26 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-26 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-26 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 juicer
+;; WARN: Return type mismatch process-focusable vs juicer.
+(defmethod relocate juicer ((obj juicer) (arg0 int))
+  (if (nonzero? (-> obj intro-path))
+      (&+! (-> obj intro-path) arg0)
+      )
+  (if (nonzero? (-> obj joint))
+      (&+! (-> obj joint) arg0)
+      )
+  (the-as
+    juicer
+    ((the-as (function process-focusable int process-focusable) (find-parent-method juicer 7)) obj arg0)
+    )
+  )
+
+;; definition for method 115 of type juicer
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-115 juicer ((obj juicer))
+  "@abstract"
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-juicer" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (enemy-method-113 obj *juicer-nav-enemy-info*)
+  (let ((v1-5 (-> obj neck)))
+    (set! (-> v1-5 up) (the-as uint 1))
+    (set! (-> v1-5 nose) (the-as uint 2))
+    (set! (-> v1-5 ear) (the-as uint 0))
+    (set-vector! (-> v1-5 twist-max) 11832.889 11832.889 0.0 1.0)
+    (set! (-> v1-5 ignore-angle) 30947.555)
+    )
+  (let ((v1-7 (-> obj nav)))
+    (set! (-> v1-7 speed-scale) 1.0)
+    )
+  0
+  (set-gravity-length (-> obj root-override2 dynam) 573440.0)
+  (set! (-> obj last-fire-time) 0)
+  (set! (-> obj heading) (the-as basic (if (rand-vu-percent? 0.5)
+                                           #t
+                                           #f
+                                           )
+                                 )
+        )
+  (set! (-> obj move-angle) 5461.3335)
+  (set! (-> obj torso-track-player) #f)
+  (new-source! (-> obj los) obj (seconds 0.2) (collide-spec backgnd obstacle))
+  (set! (-> obj joint) (new 'process 'joint-mod (joint-mod-mode joint-set*-world) obj 5))
+  (set! (-> obj using-turn-anim) #f)
+  (let ((v1-18 (new 'process 'path-control obj 'intro 0.0 (the-as entity #f) #t)))
+    (set! (-> obj intro-path) v1-18)
+    (if (nonzero? v1-18)
+        (logior! (-> v1-18 flags) (path-control-flag display draw-line draw-point draw-text))
+        )
+    )
+  (add-connection
+    *part-engine*
+    obj
+    34
+    obj
+    318
+    (new 'static 'vector :x 901.12 :y -1146.88 :z 1269.76 :w 163840.0)
+    )
+  (add-connection
+    *part-engine*
+    obj
+    34
+    obj
+    318
+    (new 'static 'vector :x -901.12 :y -1146.88 :z 1269.76 :w 163840.0)
+    )
+  (add-connection *part-engine* obj 20 obj 4635 (new 'static 'vector :w 163840.0))
+  (set! (-> obj root-override2 pause-adjust-distance) 81920.0)
+  (set! (-> obj current-projectile) (the-as handle #f))
+  0
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/atoll/sniper_REF.gc b/test/decompiler/reference/jak2/levels/atoll/sniper_REF.gc
new file mode 100644
index 0000000000..a339f7cbe3
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/atoll/sniper_REF.gc
@@ -0,0 +1,301 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type sniper
+(deftype sniper (spyder)
+  ((next-pick-time time-frame  :offset-assert 944)
+   )
+  :heap-base #x340
+  :method-count-assert 186
+  :size-assert         #x3b8
+  :flag-assert         #xba034003b8
+  )
+
+;; definition for method 3 of type sniper
+(defmethod inspect sniper ((obj sniper))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type spyder inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tnext-pick-time: ~D~%" (-> obj next-pick-time))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for symbol *sniper-nav-enemy-info*, type nav-enemy-info
+(define *sniper-nav-enemy-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #t
+    :use-victory #t
+    :use-jump-blocked #t
+    :debug-draw-neck #f
+    :jump-debug-draw #f
+    :move-to-ground #t
+    :hover-if-no-ground #f
+    :idle-anim-script (new 'static 'array idle-control-frame 2
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x4 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 4
+    :notice-anim 6
+    :hostile-anim 8
+    :hit-anim 15
+    :knocked-anim 16
+    :knocked-land-anim 20
+    :die-anim 12
+    :die-falling-anim 11
+    :victory-anim 7
+    :jump-wind-up-anim 14
+    :jump-in-air-anim 14
+    :jump-land-anim 23
+    :neck-joint 6
+    :look-at-joint 7
+    :bullseye-joint 5
+    :sound-hit (static-sound-name "sniper-hit")
+    :sound-die (static-sound-name "sniper-die")
+    :notice-distance (meters 1)
+    :notice-distance-delta (meters 10)
+    :proximity-notice-distance (meters 1)
+    :default-hit-points 12
+    :gnd-collide-with (collide-spec backgnd)
+    :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.8
+    :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 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 131072.0
+    :knocked-red-vy-lo 94208.0
+    :knocked-red-vy-hi 139264.0
+    :knocked-blue-vxz-lo 40960.0
+    :knocked-blue-vxz-hi 49152.0
+    :knocked-blue-vy-lo 57344.0
+    :knocked-blue-vy-hi 98304.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 #t
+    :use-pacing #t
+    :walk-anim 5
+    :turn-anim -1
+    :run-anim 8
+    :taunt-anim -1
+    :run-travel-speed (meters 12)
+    :run-acceleration (meters 1)
+    :run-turning-acceleration (meters 50)
+    :walk-travel-speed (meters 4)
+    :walk-acceleration (meters 1)
+    :walk-turning-acceleration (meters 3)
+    :maximum-rotation-rate (degrees 360.0)
+    :notice-nav-radius (meters 1)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :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! (-> *sniper-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+;; definition for method 12 of type sniper
+(defmethod run-logic? sniper ((obj sniper))
+  (let ((f0-0 573440.0))
+    (>= (* f0-0 f0-0) (vector-vector-distance-squared (-> obj root-override2 trans) (camera-pos)))
+    )
+  )
+
+;; definition for method 129 of type sniper
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-129 sniper ((obj sniper))
+  (let ((a0-1 *target*))
+    (if a0-1
+        (set! (-> obj focus handle) (process->handle a0-1))
+        (set! (-> obj focus handle) (the-as handle #f))
+        )
+    )
+  (set! (-> obj focus aware) (if (>= (vector-vector-distance (-> obj root-override2 trans) (camera-pos))
+                                     (-> obj fact-info-override idle-distance)
+                                     )
+                                 (enemy-aware enemy-aware-0)
+                                 (enemy-aware enemy-aware-1)
+                                 )
+        )
+  (none)
+  )
+
+;; definition for method 156 of type sniper
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod nav-enemy-method-156 sniper ((obj sniper))
+  (let ((s4-0 (-> obj path curve num-cverts)))
+    (if (<= s4-0 0)
+        (go process-drawable-art-error "no path")
+        )
+    (let ((s2-0 (get-rand-int obj s4-0))
+          (gp-0 (new 'stack-no-clear 'vector))
+          )
+      (countdown (s3-0 s4-0)
+        (get-point-in-path! (-> obj path) gp-0 (the float s2-0) 'interp)
+        (if (< 409.6 (vector-vector-xz-distance gp-0 (-> obj root-override2 trans)))
+            (goto cfg-9)
+            )
+        (set! s2-0 (mod (+ s2-0 1) s4-0))
+        )
+      (label cfg-9)
+      (let ((v1-16 (-> obj nav state)))
+        (logclear! (-> v1-16 flags) (nav-state-flag directional-mode))
+        (logior! (-> v1-16 flags) (nav-state-flag target-poly-dirty))
+        (set! (-> v1-16 target-post quad) (-> gp-0 quad))
+        )
+      )
+    )
+  0
+  0
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate active (sniper)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type spyder active) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self next-pick-time) (-> self clock frame-counter))
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (let ((f30-0 (get-rand-float-range self 0.9 1.1)))
+      (until #f
+        (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override walk-anim))
+                    :num! (seek!
+                      (the float
+                           (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override walk-anim)))
+                                  frames
+                                  num-frames
+                                  )
+                              -1
+                              )
+                           )
+                      f30-0
+                      )
+                    :frame-num 0.0
+                    )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek! max f30-0))
+          )
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (when (or (logtest? (-> self nav state flags) (nav-state-flag at-target))
+              (nav-enemy-method-163 self)
+              (>= (-> self clock frame-counter) (-> self next-pick-time))
+              )
+      (nav-enemy-method-156 self)
+      (nav-enemy-method-162 self)
+      (set! (-> self next-pick-time) (+ (-> self clock frame-counter) (get-rand-int-range self 300 1050)))
+      )
+    (nav-enemy-method-176 self)
+    (none)
+    )
+  )
+
+;; definition for method 115 of type sniper
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-115 sniper ((obj sniper))
+  "@abstract"
+  (let ((t9-0 (method-of-type spyder enemy-method-115)))
+    (t9-0 obj)
+    )
+  (enemy-method-112 obj *sniper-nav-enemy-info*)
+  (logior! (-> obj focus-status) (focus-status ignore))
+  (logclear! (-> obj focus-status) (focus-status dangerous))
+  (logclear! (-> obj enemy-flags) (enemy-flag check-water))
+  0
+  (none)
+  )
+
+;; definition for method 114 of type sniper
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-114 sniper ((obj sniper))
+  "@abstract"
+  (let ((t9-0 (method-of-type spyder enemy-method-114)))
+    (t9-0 obj)
+    )
+  (let ((v1-2 (-> obj root-override2 root-prim)))
+    (set! (-> v1-2 prim-core collide-as) (collide-spec))
+    (set! (-> v1-2 prim-core collide-with) (collide-spec))
+    )
+  (set! (-> obj root-override2 backup-collide-as) (collide-spec))
+  (set! (-> obj root-override2 backup-collide-with) (collide-spec))
+  0
+  0
+  (none)
+  )
+
+;; definition for method 116 of type sniper
+;; WARN: Return type mismatch object vs none.
+(defmethod go-idle sniper ((obj sniper))
+  (with-pp
+    (cond
+      ((eval!
+         (new 'stack 'script-context (the-as basic (process->ppointer pp)) pp (the-as vector #f))
+         (res-lump-struct (-> obj entity) 'on-activate pair)
+         )
+       (cleanup-for-death obj)
+       (go (method-of-object obj die-fast))
+       )
+      (else
+        (go (method-of-object obj idle))
+        )
+      )
+    (none)
+    )
+  )
diff --git a/test/decompiler/reference/jak2/levels/city/common/transport_REF.gc b/test/decompiler/reference/jak2/levels/city/common/transport_REF.gc
new file mode 100644
index 0000000000..77040e77d8
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/city/common/transport_REF.gc
@@ -0,0 +1,663 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; failed to figure out what this is:
+(defskelgroup skel-vehicle-turret vehicle-turret vehicle-turret-lod0-jg vehicle-turret-idle-ja
+              ((vehicle-turret-lod0-mg (meters 20))
+               (vehicle-turret-lod1-mg (meters 40))
+               (vehicle-turret-lod2-mg (meters 999999))
+               )
+              :bounds (static-spherem 0 0 0 2)
+              )
+
+;; definition for symbol *transport-turret-state-info*, type traffic-guard-type-settings
+(define *transport-turret-state-info* (new 'static 'traffic-guard-type-settings
+                                        :acquire-delay #x1c2
+                                        :shot-delay #x4b
+                                        :burst-delay #x384
+                                        :shot-count 2
+                                        :rand-shot-count 1
+                                        )
+        )
+
+;; definition of type vehicle-turret
+(deftype vehicle-turret (process-focusable)
+  ((turret-jm joint-mod              :offset-assert 204)
+   (turret    turret-control :inline :offset-assert 208)
+   (target    handle                 :offset-assert 288)
+   )
+  :heap-base #xb0
+  :method-count-assert 31
+  :size-assert         #x128
+  :flag-assert         #x1f00b00128
+  (:methods
+    (idle () _type_ :state 27)
+    (vehicle-turret-method-28 (_type_) none 28)
+    (vehicle-turret-method-29 (_type_) none 29)
+    (vehicle-turret-method-30 (_type_) none 30)
+    )
+  )
+
+;; definition for method 3 of type vehicle-turret
+(defmethod inspect vehicle-turret ((obj vehicle-turret))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-focusable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tturret-jm: ~A~%" (-> obj turret-jm))
+  (format #t "~2Tturret: #<turret-control @ #x~X>~%" (-> obj turret))
+  (format #t "~2Ttarget: ~D~%" (-> obj target))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for method 29 of type vehicle-turret
+;; WARN: Return type mismatch int vs none.
+(defmethod vehicle-turret-method-29 vehicle-turret ((obj vehicle-turret))
+  (let* ((s4-0 (ppointer->process (-> obj parent)))
+         (s5-0 (if (type? s4-0 process-focusable)
+                   s4-0
+                   )
+               )
+         )
+    (when s5-0
+      (let ((a2-0 (matrix<-transformq!
+                    (new 'stack-no-clear 'matrix)
+                    (the-as transformq (-> (the-as process-drawable s5-0) root trans))
+                    )
+                  )
+            )
+        (vector-matrix*! (-> obj root-override trans) (new 'static 'vector :y 8601.6 :z 12288.0 :w 1.0) a2-0)
+        )
+      (quaternion-copy! (-> obj root-override quat) (-> (the-as process-drawable s5-0) root quat))
+      )
+    )
+  0
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate idle (vehicle-turret)
+  :virtual #t
+  :trans (behavior ()
+    (turret-control-method-12 (-> self turret) (the-as joint-mod-rotate-local (-> self turret-jm)))
+    (vehicle-turret-method-29 self)
+    (when (and (nonzero? (-> self target)) (handle->process (-> self target)))
+      (let* ((s5-0 (handle->process (-> self target)))
+             (gp-0 (if (type? s5-0 process-focusable)
+                       s5-0
+                       )
+                   )
+             (s5-1 (new 'stack-no-clear 'vector))
+             )
+        (set! (-> s5-1 quad) (-> (get-trans (the-as process-focusable gp-0) 3) quad))
+        (turret-control-method-11
+          (-> self turret)
+          self
+          s5-1
+          (-> (the-as process-focusable gp-0) root-override transv)
+          )
+        )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior vehicle-turret) sleep-code)
+  :post (the-as (function none :behavior vehicle-turret) transform-post)
+  )
+
+;; definition for method 28 of type vehicle-turret
+;; WARN: Return type mismatch int vs none.
+(defmethod vehicle-turret-method-28 vehicle-turret ((obj vehicle-turret))
+  (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 ((v1-6 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-6 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-6 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-6 prim-core action) (collide-action solid))
+      (set! (-> v1-6 transform-index) 3)
+      (set-vector! (-> v1-6 local-sphere) 0.0 0.0 0.0 4096.0)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) v1-6)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-9 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-9 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-9 prim-core collide-with))
+      )
+    (set! (-> obj root-override) s5-0)
+    )
+  0
+  (none)
+  )
+
+;; definition for method 7 of type vehicle-turret
+;; WARN: Return type mismatch process-drawable vs vehicle-turret.
+(defmethod relocate vehicle-turret ((obj vehicle-turret) (arg0 int))
+  (if (nonzero? (-> obj turret-jm))
+      (&+! (-> obj turret-jm) arg0)
+      )
+  (the-as
+    vehicle-turret
+    ((the-as (function process-drawable int process-drawable) (find-parent-method vehicle-turret 7)) obj arg0)
+    )
+  )
+
+;; definition for method 30 of type vehicle-turret
+;; WARN: Return type mismatch int vs none.
+(defmethod vehicle-turret-method-30 vehicle-turret ((obj vehicle-turret))
+  (set! (-> obj turret-jm)
+        (the-as joint-mod (new 'process 'joint-mod-rotate-local obj (-> obj turret info joint-index) #t))
+        )
+  0
+  (none)
+  )
+
+;; definition for function vehicle-turret-init-by-other
+;; WARN: Return type mismatch object vs none.
+(defbehavior vehicle-turret-init-by-other vehicle-turret ((arg0 turret-control-info))
+  (vehicle-turret-method-28 self)
+  (turret-control-method-15 (-> self turret) arg0)
+  (logior! (-> self turret flags) (turret-flag targetting-laser no-rot-y-clamp))
+  (vehicle-turret-method-29 self)
+  (vector-identity! (-> self root-override scale))
+  (vector-float*! (-> self root-override scale) (-> self root-override scale) 2.0)
+  (ctywide-entity-hack)
+  (initialize-skeleton
+    self
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-vehicle-turret" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (vehicle-turret-method-30 self)
+  (set! (-> self turret guard-settings) *transport-turret-state-info*)
+  (go-virtual idle)
+  (none)
+  )
+
+;; definition for symbol *transport-turret-control-info*, type turret-control-info
+(define *transport-turret-control-info* (new 'static 'turret-control-info
+                                          :joint-index 3
+                                          :barrel-count 1
+                                          :shot-speed 819200.0
+                                          :attack-range 102400.0
+                                          :rot-min (new 'static 'array float 2 -16384.0 -2184533.2)
+                                          :rot-max (new 'static 'array float 2 0.0 2184533.2)
+                                          :local-pos (new 'static 'vector :y -1433.6 :z 4096.0 :w 1.0)
+                                          :local-dir (new 'static 'vector :z 1.0 :w 1.0)
+                                          :barrel-array (new 'static 'inline-array turret-barrel-info 4
+                                            (new 'static 'turret-barrel-info
+                                              :local-pos (new 'static 'vector :y -1433.6 :z 4096.0 :w 1.0)
+                                              :local-dir (new 'static 'vector :z 1.0 :w 1.0)
+                                              )
+                                            (new 'static 'turret-barrel-info)
+                                            (new 'static 'turret-barrel-info)
+                                            (new 'static 'turret-barrel-info)
+                                            )
+                                          )
+        )
+
+;; definition of type transport-params
+(deftype transport-params (structure)
+  ((spawn-pos vector     :inline :offset-assert   0)
+   (quat      quaternion :inline :offset-assert  16)
+   (nav-mesh  nav-mesh           :offset-assert  32)
+   (max-guard uint32             :offset-assert  36)
+   (max-time  float              :offset-assert  40)
+   (turret?   symbol             :offset-assert  44)
+   (speeches? symbol             :offset-assert  48)
+   )
+  :method-count-assert 9
+  :size-assert         #x34
+  :flag-assert         #x900000034
+  )
+
+;; definition for method 3 of type transport-params
+(defmethod inspect transport-params ((obj transport-params))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'transport-params)
+  (format #t "~1Tspawn-pos: #<vector @ #x~X>~%" (-> obj spawn-pos))
+  (format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> obj quat))
+  (format #t "~1Tnav-mesh: ~A~%" (-> obj nav-mesh))
+  (format #t "~1Tmax-guard: ~D~%" (-> obj max-guard))
+  (format #t "~1Tmax-time: ~f~%" (-> obj max-time))
+  (format #t "~1Tturret?: ~A~%" (-> obj turret?))
+  (format #t "~1Tspeeches?: ~A~%" (-> obj speeches?))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type transport
+(deftype transport (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)
+   (ambient-sound-id      uint32      :offset-assert 252)
+   (turret                handle      :offset-assert 256)
+   )
+  :heap-base #x90
+  :method-count-assert 36
+  :size-assert         #x108
+  :flag-assert         #x2400900108
+  (:methods
+    (come-down () _type_ :state 27)
+    (idle () _type_ :state 28)
+    (leave () _type_ :state 29)
+    (die-fast () _type_ :state 30)
+    (transport-method-31 (_type_) none 31)
+    (transport-method-32 (_type_) none 32)
+    (transport-method-33 (_type_) none 33)
+    (transport-method-34 (_type_ process) none 34)
+    (transport-method-35 (_type_) none 35)
+    )
+  )
+
+;; definition for method 3 of type transport
+(defmethod inspect transport ((obj transport))
+  (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 "~2Tambient-sound-id: ~D~%" (-> obj ambient-sound-id))
+  (format #t "~2Tturret: ~D~%" (-> obj turret))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-transport 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-event-handler
+(defbehavior transport-event-handler transport ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (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))
+     )
+    (('stop-spawning)
+     (set! (-> self spawn?) #f)
+     #f
+     )
+    )
+  )
+
+;; definition for method 12 of type transport
+(defmethod run-logic? transport ((obj transport))
+  #t
+  )
+
+;; definition for method 35 of type transport
+;; WARN: Return type mismatch int vs none.
+(defmethod transport-method-35 transport ((obj transport))
+  (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)
+  )
+
+;; definition for method 10 of type transport
+(defmethod deactivate transport ((obj transport))
+  (sound-stop (the-as sound-id (-> obj ambient-sound-id)))
+  ((the-as (function process-drawable none) (find-parent-method transport 10)) obj)
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate come-down (transport)
+  :virtual #t
+  :event transport-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! transport-idle-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim transport-idle-ja) 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-method-35 self)
+    (transform-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate idle (transport)
+  :virtual #t
+  :event transport-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 ()
+    (transport-method-34 self (the-as process #f))
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 0)
+    (sound-play "tran-door-open")
+    (ja-no-eval :group! transport-hatch-open-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim transport-hatch-open-ja) 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-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-method-34 self *target*)
+    (transport-method-35 self)
+    (transform-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate die-fast (transport)
+  :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)
+  :virtual #t
+  :event transport-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! transport-hatch-close-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim transport-hatch-close-ja) 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-method-35 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
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod transport-method-33 transport ((obj transport))
+  (with-pp
+    (when (>= (- (-> pp clock frame-counter) (-> obj last-guard-spawn-time)) 0)
+      (let ((s5-0 (new 'stack 'traffic-object-spawn-params)))
+        (set! (-> s5-0 object-type) (the-as uint 6))
+        (set! (-> s5-0 behavior) (the-as uint 6))
+        (set! (-> s5-0 id) (the-as uint 0))
+        (set! (-> s5-0 nav-mesh) (-> obj nav-mesh))
+        (set! (-> s5-0 nav-branch) #f)
+        (set! (-> s5-0 proc) #f)
+        (set! (-> s5-0 handle) (the-as uint (process->handle obj)))
+        (set! (-> s5-0 user-data) (-> obj spawn-side))
+        (set! (-> s5-0 flags) (the-as uint 0))
+        (set! (-> s5-0 guard-type) (the-as uint 7))
+        (vector-reset! (-> s5-0 velocity))
+        (set! (-> s5-0 position quad) (-> obj root-override trans quad))
+        (set! (-> s5-0 position y) (+ 8192.0 (-> s5-0 position y)))
+        (quaternion-rotate-local-y! (-> s5-0 rotation) (-> obj root-override quat) 32768.0)
+        (send-event *traffic-manager* 'activate-object s5-0)
+        (when (-> s5-0 proc)
+          (set! (-> obj spawn-side) (- 1 (the-as int (-> obj spawn-side))))
+          (if (logtest? (-> obj draw status) (draw-control-status on-screen))
+              (set! (-> obj last-guard-spawn-time) (+ (-> pp clock frame-counter) (seconds 1)))
+              (set! (-> obj last-guard-spawn-time) (+ (-> pp clock frame-counter) (seconds 2)))
+              )
+          (+! (-> obj count-guard) 1)
+          )
+        (when (not (-> s5-0 proc))
+          (if (logtest? (-> obj draw status) (draw-control-status on-screen))
+              (set! (-> obj last-guard-spawn-time) (+ (-> pp clock frame-counter) (seconds 0.1)))
+              (set! (-> obj last-guard-spawn-time) (+ (-> pp clock frame-counter) (seconds 1)))
+              )
+          )
+        )
+      )
+    (none)
+    )
+  )
+
+;; definition for method 34 of type transport
+;; WARN: Return type mismatch int vs none.
+(defmethod transport-method-34 transport ((obj transport) (arg0 process))
+  (let ((v1-1 (handle->process (-> obj turret))))
+    (if v1-1
+        (set! (-> (the-as vehicle-turret v1-1) target) (process->handle arg0))
+        )
+    )
+  0
+  (none)
+  )
+
+;; definition for method 31 of type transport
+;; WARN: Return type mismatch int vs none.
+(defmethod transport-method-31 transport ((obj transport))
+  (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
+;; WARN: Return type mismatch int vs none.
+(defmethod transport-method-32 transport ((obj transport))
+  (set! (-> obj spawn-side) (the-as uint 0))
+  0
+  (none)
+  )
+
+;; definition for function transport-init-by-other
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defbehavior transport-init-by-other transport ((arg0 transport-params))
+  (transport-method-31 self)
+  (set! (-> self root-override trans quad) (-> arg0 spawn-pos quad))
+  (quaternion-copy! (-> self root-override quat) (-> arg0 quat))
+  (vector-identity! (-> self root-override scale))
+  (set! (-> self max-guard) (-> arg0 max-guard))
+  (set! (-> self count-guard) (the-as uint 0))
+  (set! (-> self nav-mesh) (-> arg0 nav-mesh))
+  (set! (-> self max-time) 0.0)
+  (initialize-skeleton
+    self
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-transport" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (transport-method-32 self)
+  (set! (-> self y-dest) (-> self root-override trans y))
+  (set! (-> self root-override trans y) (+ 163840.0 (-> self root-override trans y)))
+  (set! (-> self spawn?) #t)
+  (set! (-> self leave-time) 0)
+  (if (-> arg0 turret?)
+      (set! (-> self turret)
+            (ppointer->handle (process-spawn vehicle-turret *transport-turret-control-info* :to self))
+            )
+      (set! (-> self turret) (the-as handle #f))
+      )
+  (set! (-> self ambient-sound-id) (the-as uint (new-sound-id)))
+  (go-virtual come-down)
+  (none)
+  )
+
+;; definition for method 11 of type transport
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! transport ((obj transport) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (transport-method-31 obj)
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-transport" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (transport-method-32 obj)
+  (set! (-> obj spawn?) #t)
+  (go (method-of-object obj come-down))
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/city/farm/yakow_REF.gc b/test/decompiler/reference/jak2/levels/city/farm/yakow_REF.gc
new file mode 100644
index 0000000000..94003d4c6a
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/city/farm/yakow_REF.gc
@@ -0,0 +1,479 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; failed to figure out what this is:
+(defskelgroup skel-yakow yakow yakow-lod0-jg yakow-idle-ja
+              ((yakow-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 1 0 4)
+              )
+
+;; definition of type yakow
+(deftype yakow (nav-enemy)
+  ((incoming-attack-id uint32  :offset-assert 604)
+   (grazing            basic   :offset-assert 608)
+   )
+  :heap-base #x1f0
+  :method-count-assert 179
+  :size-assert         #x264
+  :flag-assert         #xb301f00264
+  (:methods
+    (kicked () _type_ :state 178)
+    )
+  )
+
+;; definition for method 3 of type yakow
+(defmethod inspect yakow ((obj yakow))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type nav-enemy inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tincoming-attack-id: ~D~%" (-> obj incoming-attack-id))
+  (format #t "~2Tgrazing: ~A~%" (-> obj grazing))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for symbol *yakow-nav-enemy-info*, type nav-enemy-info
+(define *yakow-nav-enemy-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #f
+    :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 idle-control-frame 4
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x3 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 3
+    :notice-anim 3
+    :hostile-anim 6
+    :hit-anim 3
+    :knocked-anim 7
+    :knocked-land-anim 7
+    :die-anim -1
+    :die-falling-anim -1
+    :victory-anim -1
+    :jump-wind-up-anim -1
+    :jump-in-air-anim -1
+    :jump-land-anim -1
+    :neck-joint 5
+    :look-at-joint 6
+    :bullseye-joint 4
+    :sound-hit (static-sound-name "yakow-hit")
+    :sound-die (static-sound-name "yakow-die")
+    :notice-distance (meters 30)
+    :notice-distance-delta (meters 10)
+    :default-hit-points 5
+    :gnd-collide-with (collide-spec backgnd)
+    :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.8
+    :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 2730.6667
+    :knocked-soft-vxz-lo 16384.0
+    :knocked-soft-vxz-hi 16384.0
+    :knocked-soft-vy-lo 16384.0
+    :knocked-soft-vy-hi 16384.0
+    :knocked-medium-vxz-lo 16384.0
+    :knocked-medium-vxz-hi 16384.0
+    :knocked-medium-vy-lo 16384.0
+    :knocked-medium-vy-hi 16384.0
+    :knocked-hard-vxz-lo 16384.0
+    :knocked-hard-vxz-hi 16384.0
+    :knocked-hard-vy-lo 16384.0
+    :knocked-hard-vy-hi 16384.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 16384.0
+    :knocked-yellow-vxz-hi 16384.0
+    :knocked-yellow-vy-lo 16384.0
+    :knocked-yellow-vy-hi 16384.0
+    :knocked-red-vxz-lo 16384.0
+    :knocked-red-vxz-hi 16384.0
+    :knocked-red-vy-lo 16384.0
+    :knocked-red-vy-hi 16384.0
+    :knocked-blue-vxz-lo 16384.0
+    :knocked-blue-vxz-hi 16384.0
+    :knocked-blue-vy-lo 16384.0
+    :knocked-blue-vy-hi 16384.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)
+    :callback-info #f
+    :use-momentum #t
+    :use-frustration #f
+    :use-stop-chase #f
+    :use-circling #f
+    :use-pacing #f
+    :walk-anim 5
+    :turn-anim -1
+    :run-anim 6
+    :taunt-anim -1
+    :run-travel-speed (meters 6)
+    :run-acceleration (meters 1)
+    :run-turning-acceleration (meters 1)
+    :walk-travel-speed (meters 2.13)
+    :walk-acceleration (meters 1)
+    :walk-turning-acceleration (meters 1)
+    :maximum-rotation-rate (degrees 50.000004)
+    :notice-nav-radius (meters 1)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :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! (-> *yakow-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+;; definition for method 56 of type yakow
+(defmethod enemy-method-56 yakow ((obj yakow) (arg0 process) (arg1 event-message-block))
+  0
+  )
+
+;; definition for method 74 of type yakow
+(defmethod enemy-method-74 yakow ((obj yakow) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (case arg2
+    (('attack)
+     (let ((v1-1 (the-as object (-> arg3 param 1))))
+       (when (!= (-> (the-as attack-info v1-1) id) (-> obj incoming-attack-id))
+         (set! (-> obj incoming-attack-id) (-> (the-as attack-info v1-1) id))
+         (go (method-of-object obj kicked))
+         )
+       )
+     )
+    (else
+      ((method-of-type nav-enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+      )
+    )
+  )
+
+;; definition for method 123 of type yakow
+(defmethod enemy-method-123 yakow ((obj yakow) (arg0 float))
+  "TODO"
+  (>= arg0 (rand-vu))
+  )
+
+;; definition for method 156 of type yakow
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+;; WARN: Function (method 156 yakow) has a return type of none, but the expression builder found a return statement.
+(defmethod nav-enemy-method-156 yakow ((obj yakow))
+  (dotimes (s5-0 16)
+    (let ((f30-1 (* 4096.0 (get-rand-float-range obj -10.0 10.0)))
+          (f0-2 (* 4096.0 (get-rand-float-range obj -10.0 10.0)))
+          (s4-0 (new 'stack-no-clear 'vector))
+          )
+      (set! (-> s4-0 quad) (-> obj root-override2 trans quad))
+      (+! (-> s4-0 x) f30-1)
+      (+! (-> s4-0 z) f0-2)
+      (let ((v1-7 (-> obj nav))
+            (a0-6 s4-0)
+            (a1-2 (new 'stack-no-clear 'nav-find-poly-parms))
+            )
+        (vector-! (-> a1-2 point) a0-6 (-> v1-7 state mesh bounds))
+        (set! (-> a1-2 y-threshold) (-> v1-7 nearest-y-threshold))
+        (set! (-> a1-2 ignore) (the-as uint 2))
+        (when (find-poly-containing-point-local (-> v1-7 state mesh) a1-2)
+          (let ((v1-12 (-> obj nav state)))
+            (logclear! (-> v1-12 flags) (nav-state-flag directional-mode))
+            (logior! (-> v1-12 flags) (nav-state-flag target-poly-dirty))
+            (set! (-> v1-12 target-post quad) (-> s4-0 quad))
+            )
+          0
+          (return #f)
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate idle (yakow)
+  :virtual #t
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.15))
+    (until #f
+      (let ((f30-0 (rand-vu-float-range 0.9 1.1)))
+        (ja-no-eval :group! yakow-idle-ja
+                    :num! (seek! (the float (+ (-> (the-as art-joint-anim yakow-idle-ja) frames num-frames) -1)) f30-0)
+                    :frame-num 0.0
+                    )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek! max f30-0))
+          )
+        )
+      (when (rand-vu-percent? 0.25)
+        (ja-channel-push! 1 (seconds 0.1))
+        (ja-no-eval :group! yakow-graze-ja
+                    :num! (seek! (the float (+ (-> (the-as art-joint-anim yakow-graze-ja) frames num-frames) -1)))
+                    :frame-num 0.0
+                    )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek!))
+          )
+        (ja-channel-push! 1 (seconds 0.1))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (if (and (nonzero? (-> self draw)) (logtest? (-> self draw status) (draw-control-status on-screen)))
+        (set! (-> self last-draw-time) (the-as uint (-> self clock frame-counter)))
+        )
+    (enemy-method-129 self)
+    (ja-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate active (yakow)
+  :virtual #t
+  :trans (behavior ()
+    (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1))
+      (if (< (the-as int (-> self focus aware)) 1)
+          (go-virtual idle)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (let ((f30-0 (get-rand-float-range self 0.9 1.1)))
+      (until #f
+        (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override walk-anim))
+                    :num! (seek!
+                      (the float
+                           (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override walk-anim)))
+                                  frames
+                                  num-frames
+                                  )
+                              -1
+                              )
+                           )
+                      f30-0
+                      )
+                    :frame-num 0.0
+                    )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek! max f30-0))
+          )
+        (when (enemy-method-123 self 0.2)
+          (ja-no-eval :num! (loop!))
+          (ja-channel-push! 1 (seconds 0.6))
+          (let ((v1-37 self))
+            (set! (-> v1-37 enemy-flags) (the-as enemy-flag (logclear (-> v1-37 enemy-flags) (enemy-flag enemy-flag36))))
+            (set! (-> v1-37 nav callback-info) *nav-enemy-null-callback-info*)
+            )
+          0
+          (nav-enemy-method-167 self)
+          (until #f
+            (let ((f28-0 (rand-vu-float-range 0.9 1.1)))
+              (ja-no-eval :group! yakow-idle-ja
+                          :num! (seek! (the float (+ (-> (the-as art-joint-anim yakow-idle-ja) frames num-frames) -1)) f28-0)
+                          :frame-num 0.0
+                          )
+              (until (ja-done? 0)
+                (suspend)
+                (ja :num! (seek! max f28-0))
+                )
+              )
+            (when (rand-vu-percent? 0.25)
+              (ja-channel-push! 1 (seconds 0.1))
+              (ja-no-eval :group! yakow-graze-ja
+                          :num! (seek! (the float (+ (-> (the-as art-joint-anim yakow-graze-ja) frames num-frames) -1)))
+                          :frame-num 0.0
+                          )
+              (until (ja-done? 0)
+                (suspend)
+                (ja :num! (seek!))
+                )
+              (ja-channel-push! 1 (seconds 0.1))
+              )
+            (if (enemy-method-123 self 0.2)
+                (goto cfg-15)
+                )
+            )
+          #f
+          (label cfg-15)
+          (let ((v1-97 (-> self nav state)))
+            (set! (-> v1-97 speed) 0.0)
+            )
+          0
+          (let ((a0-23 (-> self nav state))
+                (v1-100 *null-vector*)
+                )
+            (set! (-> a0-23 velocity quad) (-> v1-100 quad))
+            )
+          0
+          (let ((v1-103 self))
+            (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-103 enemy-flags)))
+                (set! (-> v1-103 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-103 enemy-flags))))
+                )
+            (set! (-> v1-103 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-103 enemy-flags))))
+            (set! (-> v1-103 nav callback-info) (-> v1-103 enemy-info-override callback-info))
+            )
+          0
+          (nav-enemy-method-165 self)
+          (ja-no-eval :num! (loop!))
+          (ja-channel-push! 1 (seconds 0.6))
+          (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override walk-anim))
+                      :num! (seek!
+                        (the float
+                             (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override walk-anim)))
+                                    frames
+                                    num-frames
+                                    )
+                                -1
+                                )
+                             )
+                        f30-0
+                        )
+                      :frame-num 0.0
+                      )
+          (until (ja-done? 0)
+            (ja-blend-eval)
+            (suspend)
+            (ja :num! (seek! max f30-0))
+            )
+          )
+        )
+      )
+    #f
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate kicked (yakow)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior yakow) #f)
+  :enter (behavior ()
+    (let ((v1-0 self))
+      (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logclear (-> v1-0 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-0 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :exit (behavior ()
+    '()
+    (none)
+    )
+  :trans (behavior ()
+    '()
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.05))
+    (ja-no-eval :group! yakow-kicked-in-place-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim yakow-kicked-in-place-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (go-virtual active)
+    (none)
+    )
+  :post (the-as (function none :behavior yakow) ja-post)
+  )
+
+;; definition for method 114 of type yakow
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-114 yakow ((obj yakow))
+  "@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 ((v1-7 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-7 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-7 prim-core collide-with) (collide-spec backgnd jak player-list))
+      (set! (-> v1-7 prim-core action) (collide-action solid no-standon))
+      (set-vector! (-> v1-7 local-sphere) 0.0 4096.0 0.0 10240.0)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) v1-7)
+      )
+    (set! (-> s5-0 nav-radius) 10240.0)
+    (let ((v1-9 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-9 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-9 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 115 of type yakow
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-115 yakow ((obj yakow))
+  "@abstract"
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-yakow" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (enemy-method-113 obj *yakow-nav-enemy-info*)
+  (let ((v1-5 (-> obj nav)))
+    (set! (-> v1-5 speed-scale) 1.0)
+    )
+  0
+  (set-gravity-length (-> obj root-override2 dynam) 327680.0)
+  0
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/city/slums/kor/kid-h_REF.gc b/test/decompiler/reference/jak2/levels/city/slums/kor/kid-h_REF.gc
new file mode 100644
index 0000000000..0b85aaec29
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/city/slums/kor/kid-h_REF.gc
@@ -0,0 +1,85 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type kid
+(deftype kid (bot)
+  ((travel-anim-interp  float       :offset-assert 992)
+   (arrest-attempt-time time-frame  :offset-assert 1000)
+   (arrestor-handle     handle      :offset-assert 1008)
+   )
+  :heap-base #x380
+  :method-count-assert 235
+  :size-assert         #x3f8
+  :flag-assert         #xeb038003f8
+  (:methods
+    (traveling () _type_ :state 225)
+    (traveling-blocked () _type_ :state 226)
+    (waiting-with-kor () _type_ :state 227)
+    (waiting-idle () _type_ :state 228)
+    (waiting-turn () _type_ :state 229)
+    (scared-idle () _type_ :state 230)
+    (arrested () _type_ :state 231)
+    (kid-method-232 (_type_) none 232)
+    (kid-method-233 (_type_) none 233)
+    (kid-method-234 (_type_) none 234)
+    )
+  )
+
+;; definition for method 3 of type kid
+(defmethod inspect kid ((obj kid))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type bot inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Ttravel-anim-interp: ~f~%" (-> obj travel-anim-interp))
+  (format #t "~2Tarrest-attempt-time: ~D~%" (-> obj arrest-attempt-time))
+  (format #t "~2Tarrestor-handle: ~D~%" (-> obj arrestor-handle))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-kid kid kid-lod0-jg kid-idle0-ja
+              ((kid-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 2)
+              :shadow kid-shadow-mg
+              :origin-joint-index 13
+              )
+
+;; definition of type kidt-wait-spot
+(deftype kidt-wait-spot (ai-task)
+  ((check-done   (function kidt-wait-spot kid symbol)   :offset  32)
+   (which-spot   int8                                   :offset  36)
+   (num-spots    uint8                                  :offset  37)
+   (spot-indexes uint8                                6 :offset  38)
+   )
+  :method-count-assert 12
+  :size-assert         #x30
+  :flag-assert         #xc00000030
+  )
+
+;; definition for method 3 of type kidt-wait-spot
+(defmethod inspect kidt-wait-spot ((obj kidt-wait-spot))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj (-> obj type))
+  (format #t "~1Tnext: ~A~%" (-> obj next))
+  (format #t "~1Tprev: ~A~%" (-> obj prev))
+  (format #t "~1Tpool: ~A~%" (-> obj pool))
+  (format #t "~1Tunique-id: ~D~%" (-> obj unique-id))
+  (format #t "~1Tbytes[16] @ #x~X~%" (-> obj bytes))
+  (format #t "~1Tcheck-done: ~A~%" (-> obj check-done))
+  (format #t "~1Twhich-spot: ~D~%" (-> obj which-spot))
+  (format #t "~1Tnum-spots: ~D~%" (-> obj num-spots))
+  (format #t "~1Tspot-indexes[6] @ #x~X~%" (-> obj spot-indexes))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+0
diff --git a/test/decompiler/reference/jak2/levels/city/slums/kor/kid-states_REF.gc b/test/decompiler/reference/jak2/levels/city/slums/kor/kid-states_REF.gc
new file mode 100644
index 0000000000..cf999b9c74
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/city/slums/kor/kid-states_REF.gc
@@ -0,0 +1,658 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; failed to figure out what this is:
+(defstate waiting-idle (kid)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kid) 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
+    (nav-enemy-method-167 self)
+    (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))
+    (enemy-method-109 self 1)
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (b!
+      (not (and (-> self focus-info fproc) (>= (fabs (-> self focus-info ry-diff)) 9102.223)))
+      cfg-6
+      :delay (empty-form)
+      )
+    (kid-method-233 self)
+    (b! #t cfg-15 :delay (nop!))
+    (label cfg-6)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (if (if (type? gp-0 process-focusable)
+              gp-0
+              )
+          (go-virtual arrested)
+          )
+      )
+    (label cfg-15)
+    (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+      (if (not (outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #f))
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((v1-2 (ja-group)))
+      (cond
+        ((and v1-2 (= v1-2 (-> self draw art-group data 3)))
+         (ja-no-eval :num! (seek!))
+         (while (not (ja-done? 0))
+           (suspend)
+           (ja-eval)
+           )
+         )
+        (else
+          (ja-channel-push! 1 (seconds 0.2))
+          )
+        )
+      )
+    (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 (the-as (function none :behavior kid) nav-enemy-simple-post)
+  )
+
+;; failed to figure out what this is:
+(defstate waiting-turn (kid)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kid) 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
+    (nav-enemy-method-167 self)
+    (let ((v1-7 self))
+      (set! (-> v1-7 enemy-flags) (the-as enemy-flag (logclear (-> v1-7 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (enemy-method-109 self 1)
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+      (if (and (not (outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #f))
+               (let ((gp-0 (handle->process (-> self arrestor-handle))))
+                 (not (if (type? gp-0 process-focusable)
+                          gp-0
+                          )
+                      )
+                 )
+               )
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (local-vars (s4-1 art-element) (f0-9 float))
+    (let ((gp-0 (new 'stack-no-clear 'bot-turn-info)))
+      (let ((s5-0 (-> self focus-info fproc)))
+        (if (not s5-0)
+            (kid-method-232 self)
+            )
+        (turn-to-target self gp-0 s5-0 0.8)
+        )
+      (let ((s4-0 (>= (-> gp-0 predicted-ry-diff) 0.0)))
+        (let ((s5-1 (-> self draw art-group data (if s4-0
+                                                     7
+                                                     11
+                                                     )
+                        )
+                    )
+              )
+          (ja-channel-push! 1 (seconds 0.4))
+          (ja-no-eval :group! s5-1
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim s5-1) frames num-frames) -1)))
+                      :frame-num 0.0
+                      )
+          )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek!))
+          )
+        (let ((a2-3 (-> self focus-info fproc)))
+          (if a2-3
+              (turn-to-target self gp-0 a2-3 0.533)
+              )
+          )
+        (let ((s5-2 (new 'stack-no-clear 'quaternion))
+              (f0-8 (-> gp-0 predicted-ry-diff))
+              (f30-0 5.0)
+              (f28-0 7.0)
+              )
+          (cond
+            (s4-0
+              (if (< f0-8 0.0)
+                  (set! f0-8 (+ 65536.0 f0-8))
+                  )
+              (cond
+                ((< f0-8 18204.445)
+                 (set! f0-9 9102.223)
+                 (set! s4-1 (-> self draw art-group data 8))
+                 (set! f28-0 8.0)
+                 )
+                ((< f0-8 27306.666)
+                 (set! f0-9 18204.445)
+                 (set! s4-1 (-> self draw art-group data 9))
+                 )
+                (else
+                  (set! f0-9 27306.666)
+                  (set! s4-1 (-> self draw art-group data 10))
+                  )
+                )
+              )
+            (else
+              (if (>= f0-8 0.0)
+                  (set! f0-8 (+ -65536.0 f0-8))
+                  )
+              (cond
+                ((< -18204.445 f0-8)
+                 (set! f0-9 -9102.223)
+                 (set! s4-1 (-> self draw art-group data 12))
+                 (set! f28-0 8.0)
+                 )
+                ((< -27306.666 f0-8)
+                 (set! f0-9 -18204.445)
+                 (set! s4-1 (-> self draw art-group data 13))
+                 )
+                (else
+                  (set! f0-9 -27306.666)
+                  (set! s4-1 (-> self draw art-group data 14))
+                  )
+                )
+              )
+            )
+          (quaternion-rotate-y! s5-2 (-> gp-0 src-quat) f0-9)
+          (ja-no-eval :group! s4-1
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim s4-1) frames num-frames) -1)))
+                      :frame-num 0.0
+                      )
+          (until (ja-done? 0)
+            (let ((f0-14 (ja-aframe-num 0)))
+              (cond
+                ((< f0-14 f28-0)
+                 (if (>= f0-14 f30-0)
+                     (quaternion-slerp! (-> self root-override2 quat) (-> gp-0 src-quat) s5-2 (/ (- f0-14 f30-0) (- f28-0 f30-0)))
+                     )
+                 )
+                (else
+                  (quaternion-copy! (-> self root-override2 quat) s5-2)
+                  )
+                )
+              )
+            (suspend)
+            (ja :num! (seek!))
+            )
+          )
+        )
+      )
+    (kid-method-232 self)
+    (none)
+    )
+  :post (the-as (function none :behavior kid) nav-enemy-simple-post)
+  )
+
+;; failed to figure out what this is:
+(defstate waiting-with-kor (kid)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kid) enemy-event-handler)
+  :enter (-> (method-of-type kid waiting-idle) enter)
+  :exit (-> (method-of-type kid waiting-idle) exit)
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+      (if (not (outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #f))
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (-> (method-of-type kid waiting-idle) code)
+  :post (-> (method-of-type kid waiting-idle) post)
+  )
+
+;; failed to figure out what this is:
+(defstate scared-idle (kid)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kid) 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
+    (nav-enemy-method-167 self)
+    (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))
+    (enemy-method-109 self 1)
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (b!
+      (not (and (-> self focus-info fproc) (>= (fabs (-> self focus-info ry-diff)) 9102.223)))
+      cfg-6
+      :delay (empty-form)
+      )
+    (kid-method-233 self)
+    (b! #t cfg-15 :delay (nop!))
+    (label cfg-6)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (if (if (type? gp-0 process-focusable)
+              gp-0
+              )
+          (go-virtual arrested)
+          )
+      )
+    (label cfg-15)
+    (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+      (if (not (outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #f))
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((v1-2 (ja-group)))
+      (cond
+        ((and v1-2 (= v1-2 (-> self draw art-group data 4)))
+         (ja-no-eval :num! (seek!))
+         (while (not (ja-done? 0))
+           (suspend)
+           (ja-eval)
+           )
+         )
+        (else
+          (ja-channel-push! 1 (seconds 0.2))
+          )
+        )
+      )
+    (until #f
+      (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!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior kid) nav-enemy-simple-post)
+  )
+
+;; failed to figure out what this is:
+(defstate traveling (kid)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kid) enemy-event-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (let ((v1-2 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-2 enemy-flags)))
+          (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-2 enemy-flags))))
+          )
+      (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-2 enemy-flags))))
+      (set! (-> v1-2 nav callback-info) (-> v1-2 enemy-info-override callback-info))
+      )
+    0
+    (let ((v1-5 self))
+      (set! (-> v1-5 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-5 enemy-flags))))
+      )
+    0
+    (enemy-method-110 self)
+    (nav-enemy-method-166 self)
+    (set! (-> self player-blocking) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (cond
+        ((if (type? gp-0 process-focusable)
+             gp-0
+             )
+         (go-virtual arrested)
+         )
+        ((outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #t)
+         (kid-method-232 self)
+         )
+        ((and (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.5)) (bot-method-208 self))
+         (go-virtual traveling-blocked)
+         )
+        ((and (nav-enemy-method-163 self)
+              (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+              )
+         (go-stare2 self)
+         )
+        )
+      )
+    0
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (kid-method-234 self)
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (let ((a0-0 (-> self nav state))
+          (v1-1 (-> self spot))
+          )
+      (logclear! (-> a0-0 flags) (nav-state-flag directional-mode))
+      (logior! (-> a0-0 flags) (nav-state-flag target-poly-dirty))
+      (set! (-> a0-0 target-post quad) (-> v1-1 center quad))
+      )
+    0
+    (nav-enemy-travel-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate traveling-blocked (kid)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kid) 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
+    (nav-enemy-method-167 self)
+    (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))
+    (enemy-method-109 self 1)
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (cond
+        ((if (type? gp-0 process-focusable)
+             gp-0
+             )
+         (go-virtual arrested)
+         )
+        ((and (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1)) (not (bot-method-208 self)))
+         (go-virtual traveling)
+         )
+        )
+      )
+    (none)
+    )
+  :code (-> (method-of-type kid waiting-idle) code)
+  :post (the-as (function none :behavior kid) nav-enemy-simple-post)
+  )
+
+;; failed to figure out what this is:
+(defstate stare (kid)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type bot stare) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (let ((v1-4 self))
+      (set! (-> v1-4 enemy-flags) (the-as enemy-flag (logclear (-> v1-4 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (if (if (type? gp-0 process-focusable)
+              gp-0
+              )
+          (go-virtual arrested)
+          )
+      )
+    (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1))
+      (if (not (nav-enemy-method-163 self))
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (-> (method-of-type kid waiting-idle) code)
+  )
+
+;; failed to figure out what this is:
+(defstate hit (kid)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type bot hit) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :code (behavior ()
+    (local-vars (v1-31 enemy-flag) (v1-39 enemy-flag))
+    (ja-channel-push! 1 (seconds 0.1))
+    (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!))
+      )
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (let ((v1-30 (-> self enemy-flags)))
+      (if (logtest? v1-30 (enemy-flag checking-water))
+          (set! v1-31 (logior v1-30 (enemy-flag enable-on-active)))
+          (set! v1-31 (logclear v1-30 (enemy-flag enable-on-active)))
+          )
+      )
+    (set! (-> self enemy-flags) v1-31)
+    (if (logtest? (-> self enemy-flags) (enemy-flag look-at-move-dest))
+        (set! (-> self mask) (logior (process-mask collectable) (-> self mask)))
+        (logclear! (-> self mask) (process-mask collectable))
+        )
+    (let ((v1-38 (-> self enemy-flags)))
+      (if (logtest? (enemy-flag no-initial-move-to-ground) v1-38)
+          (set! v1-39 (logior (enemy-flag check-water-backup) v1-38))
+          (set! v1-39 (logclear v1-38 (enemy-flag check-water-backup)))
+          )
+      )
+    (set! (-> self enemy-flags) v1-39)
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (logclear! (-> self focus-status) (focus-status hit))
+    (enemy-method-72 self)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate knocked (kid)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type bot knocked) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate arrested (kid)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kid) 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
+    (nav-enemy-method-167 self)
+    (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))
+    (enemy-method-110 self)
+    (set! (-> self travel-anim-interp) 0.0)
+    (if (logtest? (bot-flags bf20) (-> self bot-flags))
+        (logclear! (-> self enemy-flags) (enemy-flag enable-on-active checking-water))
+        )
+    (none)
+    )
+  :trans (behavior ()
+    (cond
+      ((logtest? (-> self bot-flags) (bot-flags bf09))
+       (fail-falling self)
+       )
+      (else
+        (bot-method-223 self #f)
+        (when (not (logtest? (bot-flags bf20) (-> self bot-flags)))
+          (if (and (-> self focus-info fproc) (>= (fabs (-> self focus-info ry-diff)) 9102.223))
+              (kid-method-233 self)
+              )
+          (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+            (let ((gp-0 (handle->process (-> self arrestor-handle))))
+              (if (not (if (type? gp-0 process-focusable)
+                           gp-0
+                           )
+                       )
+                  (enemy-method-72 self)
+                  )
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (when (not (logtest? (bot-flags bf20) (-> self bot-flags)))
+      (ja-channel-push! 1 (seconds 0.1))
+      (ja-no-eval :group! (-> self draw art-group data 15)
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 15)) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    (fail-mission! self)
+    (let* ((gp-0 (handle->process (-> self arrestor-handle)))
+           (v1-32 (if (type? gp-0 process-focusable)
+                      gp-0
+                      )
+                  )
+           )
+      (if v1-32
+          (logclear! (-> (the-as crimson-guard v1-32) enemy-flags) (enemy-flag enable-on-active checking-water))
+          )
+      )
+    (let ((v1-35 (ja-group)))
+      (if (not (and v1-35 (= v1-35 (-> self draw art-group data 15))))
+          (ja-channel-push! 1 (seconds 0.1))
+          )
+      )
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (until #f
+      (ja-no-eval :group! (-> self draw art-group data 16)
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 16)) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (if (and (logtest? (-> self bot-flags) (bot-flags failed))
+                 (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 4))
+                 (reset? *fail-mission-control*)
+                 )
+            (reset! *fail-mission-control*)
+            )
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior kid) nav-enemy-simple-post)
+  )
+
+;; failed to figure out what this is:
+(defstate failed (kid)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self bot-flags) (logior (bot-flags bf20) (-> self bot-flags)))
+    ((-> (method-of-type kid arrested) enter))
+    (none)
+    )
+  :trans (-> (method-of-type kid arrested) trans)
+  :code (-> (method-of-type kid arrested) code)
+  :post (-> (method-of-type kid arrested) post)
+  )
+
+;; failed to figure out what this is:
+(defstate die-falling (kid)
+  :virtual #t
+  :enter (-> (method-of-type kid failed) enter)
+  :trans (-> (method-of-type kid failed) trans)
+  :code (-> (method-of-type kid failed) code)
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak2/levels/city/slums/kor/kid-task_REF.gc b/test/decompiler/reference/jak2/levels/city/slums/kor/kid-task_REF.gc
new file mode 100644
index 0000000000..de70b6038c
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/city/slums/kor/kid-task_REF.gc
@@ -0,0 +1,51 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for method 9 of type kidt-wait-spot
+;; WARN: Return type mismatch int vs none.
+(defmethod reset-task! kidt-wait-spot ((obj kidt-wait-spot))
+  "Virtual"
+  (set! (-> obj check-done) #f)
+  (set! (-> obj which-spot) -1)
+  (set! (-> obj num-spots) (the-as uint 0))
+  0
+  (none)
+  )
+
+;; definition for method 11 of type kidt-wait-spot
+;; WARN: Return type mismatch symbol vs none.
+(defmethod ai-task-method-11 kidt-wait-spot ((obj kidt-wait-spot) (arg0 bot))
+  "Virtual"
+  (let ((s4-0 (-> obj which-spot)))
+    (when (>= s4-0 0)
+      (let ((s3-0 (-> arg0 course spots (-> obj spot-indexes s4-0))))
+        (if (and (not (outside-spot-radius? arg0 s3-0 (the-as vector #f) #f)) (player-blocking-spot? arg0 s3-0))
+            (set! s4-0 -1)
+            )
+        )
+      )
+    (when (< s4-0 0)
+      (set! s4-0 (choose-spot arg0 (the-as int (-> obj num-spots)) (the-as (pointer uint) (-> obj spot-indexes))))
+      (set! (-> obj which-spot) s4-0)
+      (mem-copy!
+        (the-as pointer (-> arg0 spot))
+        (the-as pointer (-> arg0 course spots (-> obj spot-indexes s4-0)))
+        20
+        )
+      )
+    (if (logtest? *display-bot-marks* (bot-marks-controls bmc16))
+        (bot-debug-draw-spot-sphere
+          arg0
+          (the-as int (-> obj num-spots))
+          (the-as (pointer uint) (-> obj spot-indexes))
+          (the-as int (-> obj spot-indexes s4-0))
+          )
+        )
+    )
+  ((-> obj check-done) obj (the-as kid arg0))
+  (none)
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak2/levels/city/slums/kor/kid3-course_REF.gc b/test/decompiler/reference/jak2/levels/city/slums/kor/kid3-course_REF.gc
new file mode 100644
index 0000000000..5f7e1c1f8e
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/city/slums/kor/kid3-course_REF.gc
@@ -0,0 +1,236 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for function kid-update-during-battle
+;; WARN: Return type mismatch focus-status vs none.
+(defun kid-update-during-battle ((arg0 kid))
+  (let ((v1-0 *target*))
+    (if (and v1-0 (-> v1-0 next-state) (let ((v1-3 (-> v1-0 next-state name)))
+                                         (or (= v1-3 'target-darkjak-get-on) (= v1-3 'target-darkjak-get-off))
+                                         )
+             )
+        (logior! (-> arg0 focus-status) (focus-status disable))
+        (logclear! (-> arg0 focus-status) (focus-status disable))
+        )
+    )
+  (none)
+  )
+
+;; definition for symbol *kid3-course*, type bot-course
+(define *kid3-course*
+  (new 'static 'bot-course
+    :course-id #x7
+    :spot-count #x4
+    :default-check-too-far #f
+    :waypoints (new 'static 'boxed-array :type bot-waypoint
+      (new 'static 'bot-waypoint
+        :waypoint-id 1
+        :skip-to -1
+        :on-set (lambda ((arg0 kid))
+          (process-entity-status! arg0 (entity-perm-status no-kill) #t)
+          (clear-speech-flags! arg0)
+          (logior! (-> arg0 focus-status) (focus-status disable))
+          (set! (-> arg0 notice-enemy-dist) 0.0)
+          (let ((v1-5 (-> arg0 root-override2 root-prim)))
+            (set! (-> v1-5 prim-core collide-as) (collide-spec))
+            (set! (-> v1-5 prim-core collide-with) (collide-spec))
+            )
+          0
+          (move-to-point! (-> arg0 root-override2) (the-as vector (-> arg0 course spots 0)))
+          (logclear! (-> arg0 mask) (process-mask actor-pause))
+          (logclear! (-> arg0 enemy-flags) (enemy-flag notice))
+          (let ((v1-16 (get-task-by-type (-> arg0 ai-ctrl) kidt-wait-spot arg0)))
+            (set! (-> v1-16 bytes 5) (the-as uint 1))
+            (set! (-> v1-16 bytes 6) (the-as uint 0))
+            (set! (-> v1-16 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kidt-wait-spot v1-16) check-done)
+                  (the-as
+                    (function kidt-wait-spot kid symbol)
+                    (lambda ((arg0 object) (arg1 kid)) (when (< 1 (-> arg1 waypoint-request))
+                                                         (let* ((v1-4 (-> arg1 actor-group 0 data 0 actor))
+                                                                (a0-2 (if v1-4
+                                                                          (-> v1-4 extra process)
+                                                                          )
+                                                                      )
+                                                                )
+                                                           (when a0-2
+                                                             (set! (-> arg1 master-handle) (process->handle a0-2))
+                                                             (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                                                             (go-to-waypoint! arg1 2 #f)
+                                                             (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                                                             #t
+                                                             )
+                                                           )
+                                                         )
+                            )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update #f
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 2
+        :skip-to -1
+        :on-set (lambda ((arg0 kid))
+          (let ((v1-1 (-> arg0 root-override2 root-prim)))
+            (set! (-> v1-1 prim-core collide-as) (-> arg0 root-override2 backup-collide-as))
+            (set! (-> v1-1 prim-core collide-with) (-> arg0 root-override2 backup-collide-with))
+            )
+          (logclear! (-> arg0 focus-status) (focus-status disable))
+          (let ((v1-5 (get-task-by-type (-> arg0 ai-ctrl) kidt-wait-spot arg0)))
+            (set! (-> v1-5 bytes 5) (the-as uint 1))
+            (set! (-> v1-5 bytes 6) (the-as uint 0))
+            (set! (-> v1-5 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kidt-wait-spot v1-5) check-done)
+                  (the-as
+                    (function kidt-wait-spot kid symbol)
+                    (lambda ((arg0 object) (arg1 kid))
+                      (when (>= (-> arg1 waypoint-request) 6)
+                        (set! (-> arg1 root-override2 trans quad) (-> arg1 course spots 1 center quad))
+                        (set! (-> arg1 root-override2 trans w) 1.0)
+                        (quaternion-vector-angle!
+                          (-> arg1 root-override2 quat)
+                          *up-vector*
+                          (* 182.04445 (* 0.00024414062 (-> arg1 course spots 1 center w)))
+                          )
+                        (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                        (go-to-waypoint! arg1 5 #f)
+                        (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                        #t
+                        )
+                      )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update #f
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 5
+        :skip-to -1
+        :on-set (lambda ((arg0 kid))
+          (set! (-> arg0 focus-status) (logior (focus-status arrestable) (-> arg0 focus-status)))
+          (set! (-> arg0 bot-flags) (logior (bot-flags bf19) (-> arg0 bot-flags)))
+          (set! (-> arg0 notice-enemy-dist) 122880.0)
+          (let ((v1-6 (get-task-by-type (-> arg0 ai-ctrl) kidt-wait-spot arg0)))
+            (set! (-> v1-6 bytes 5) (the-as uint 1))
+            (set! (-> v1-6 bytes 6) (the-as uint 2))
+            (set! (-> v1-6 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kidt-wait-spot v1-6) check-done)
+                  (the-as
+                    (function kidt-wait-spot kid symbol)
+                    (lambda ((arg0 object) (arg1 kid))
+                      (when (outside-spot-radius? arg1 (the-as bot-spot #f) (the-as vector #f) #f)
+                        (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                        (go-to-waypoint! arg1 6 #f)
+                        (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                        #t
+                        )
+                      )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update (lambda ((arg0 kid)) (kid-update-during-battle arg0) (none))
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 6
+        :skip-to -1
+        :on-set (lambda ((arg0 kid))
+          (let ((v1-1 (get-task-by-type (-> arg0 ai-ctrl) kidt-wait-spot arg0)))
+            (set! (-> v1-1 bytes 5) (the-as uint 1))
+            (set! (-> v1-1 bytes 6) (the-as uint 3))
+            (set! (-> v1-1 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kidt-wait-spot v1-1) check-done)
+                  (the-as
+                    (function kidt-wait-spot kid symbol)
+                    (lambda ((arg0 object) (arg1 kid)) (when (>= (-> arg1 waypoint-request) 8)
+                                                         (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                                                         (go-to-waypoint! arg1 8 #f)
+                                                         (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                                                         #t
+                                                         )
+                            )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update (lambda ((arg0 kid)) (kid-update-during-battle arg0) (none))
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 8
+        :skip-to -1
+        :on-set (lambda ((arg0 kid))
+          (logclear! (-> arg0 focus-status) (focus-status disable arrestable))
+          (let ((v1-3 (get-task-by-type (-> arg0 ai-ctrl) kidt-wait-spot arg0)))
+            (set! (-> v1-3 bytes 5) (the-as uint 1))
+            (set! (-> v1-3 bytes 6) (the-as uint 3))
+            (set! (-> v1-3 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kidt-wait-spot v1-3) check-done)
+                  (the-as
+                    (function kidt-wait-spot kid symbol)
+                    (lambda ((arg0 object) (arg1 kid)) (when (>= (-> arg1 waypoint-request) 10)
+                                                         (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                                                         (go-to-waypoint! arg1 10 #f)
+                                                         (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                                                         #t
+                                                         )
+                            )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update #f
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 10
+        :skip-to -1
+        :on-set (lambda ((arg0 kid))
+          (process-entity-status! arg0 (entity-perm-status bit-4) #f)
+          (send-event arg0 'die-fast)
+          (let ((v1-4 (get-task-by-type (-> arg0 ai-ctrl) kidt-wait-spot arg0)))
+            (set! (-> v1-4 bytes 5) (the-as uint 1))
+            (set! (-> v1-4 bytes 6) (the-as uint 3))
+            (set! (-> v1-4 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kidt-wait-spot v1-4) check-done)
+                  (the-as (function kidt-wait-spot kid symbol) (lambda () #f))
+                  )
+            )
+          (none)
+          )
+        :on-update #f
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      )
+    :spots (new 'static 'inline-array bot-spot 4
+      (new 'static 'bot-spot :center (new 'static 'vector :x 2600755.2 :y 32768.0 :z -375808.0 :w 10240.0))
+      (new 'static 'bot-spot :center (new 'static 'vector :x 2616828.0 :y 32768.0 :z -382325.56 :w -357075.75))
+      (new 'static 'bot-spot :center (new 'static 'vector :x 2575360.0 :y 32727.04 :z -191078.4 :w 32768.0))
+      (new 'static 'bot-spot :center (new 'static 'vector :x 2547753.0 :y 32727.04 :z -159252.48 :w 8192.0))
+      )
+    )
+  )
+
+;; failed to figure out what this is:
+(set! (-> *bot-course-table* course 7) *kid3-course*)
+
+
+
+
diff --git a/test/decompiler/reference/jak2/levels/city/slums/kor/kid_REF.gc b/test/decompiler/reference/jak2/levels/city/slums/kor/kid_REF.gc
new file mode 100644
index 0000000000..e1dfefdc26
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/city/slums/kor/kid_REF.gc
@@ -0,0 +1,601 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *kid-nav-enemy-info*, type nav-enemy-info
+(define *kid-nav-enemy-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 idle-control-frame 2
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x3 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 3
+    :notice-anim 3
+    :hostile-anim -1
+    :hit-anim 3
+    :knocked-anim 17
+    :knocked-land-anim 18
+    :die-anim 3
+    :die-falling-anim 3
+    :victory-anim -1
+    :jump-wind-up-anim 3
+    :jump-in-air-anim 3
+    :jump-land-anim 3
+    :neck-joint 6
+    :look-at-joint 6
+    :bullseye-joint 4
+    :notice-distance (meters 30)
+    :notice-distance-delta (meters 10)
+    :proximity-notice-distance (meters 30)
+    :default-hit-points 100
+    :gnd-collide-with (collide-spec backgnd)
+    :overlaps-others-collide-with-filter (collide-spec jak civilian enemy vehicle-sphere hit-by-others-list player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.7
+    :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 2730.6667
+    :knocked-soft-vxz-lo 40960.0
+    :knocked-soft-vxz-hi 40960.0
+    :knocked-soft-vy-lo 12288.0
+    :knocked-soft-vy-hi 12288.0
+    :knocked-medium-vxz-lo 40960.0
+    :knocked-medium-vxz-hi 40960.0
+    :knocked-medium-vy-lo 12288.0
+    :knocked-medium-vy-hi 12288.0
+    :knocked-hard-vxz-lo 40960.0
+    :knocked-hard-vxz-hi 40960.0
+    :knocked-hard-vy-lo 12288.0
+    :knocked-hard-vy-hi 12288.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 40960.0
+    :knocked-yellow-vxz-hi 40960.0
+    :knocked-yellow-vy-lo 12288.0
+    :knocked-yellow-vy-hi 12288.0
+    :knocked-red-vxz-lo 40960.0
+    :knocked-red-vxz-hi 40960.0
+    :knocked-red-vy-lo 12288.0
+    :knocked-red-vy-hi 12288.0
+    :knocked-blue-vxz-lo 40960.0
+    :knocked-blue-vxz-hi 40960.0
+    :knocked-blue-vy-lo 12288.0
+    :knocked-blue-vy-hi 12288.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 #t
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #f
+    :use-pacing #f
+    :walk-anim 3
+    :turn-anim -1
+    :run-anim 3
+    :taunt-anim -1
+    :run-travel-speed (meters 5.5)
+    :run-acceleration (meters 5)
+    :run-turning-acceleration (meters 6)
+    :walk-travel-speed (meters 1.5)
+    :walk-acceleration (meters 5)
+    :walk-turning-acceleration (meters 6)
+    :maximum-rotation-rate (degrees 180.0)
+    :notice-nav-radius (meters 0.85)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :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! (-> *kid-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+;; definition for method 74 of type kid
+(defmethod enemy-method-74 kid ((obj kid) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (with-pp
+    (case arg2
+      (('arrest)
+       (let* ((s4-0 (handle->process (-> obj arrestor-handle)))
+              (v1-4 (if (type? s4-0 process-focusable)
+                        s4-0
+                        )
+                    )
+              )
+         (when (or (not v1-4)
+                   (= v1-4 arg0)
+                   (and (!= v1-4 arg0) (>= (- (-> pp clock frame-counter) (-> obj arrest-attempt-time)) (seconds 0.1)))
+                   )
+           (set! (-> obj arrestor-handle) (process->handle arg0))
+           (set! (-> obj arrest-attempt-time) (-> pp clock frame-counter))
+           0
+           )
+         )
+       #t
+       )
+      (('instant-arrest)
+       (set! (-> obj bot-flags) (logior (bot-flags bf20) (-> obj bot-flags)))
+       (let ((v1-18 (the-as object (-> arg3 param 0))))
+         (set! (-> obj arrestor-handle) (process->handle (the-as process v1-18)))
+         (set! (-> obj arrest-attempt-time) (-> pp clock frame-counter))
+         (let ((a1-8 (new 'stack-no-clear 'vector)))
+           (vector-! a1-8 (-> (the-as process-drawable v1-18) root trans) (-> obj root-override2 trans))
+           (set! (-> a1-8 y) 0.0)
+           (forward-up->quaternion (-> obj root-override2 quat) a1-8 *up-vector*)
+           )
+         )
+       (logclear! (-> obj enemy-flags) (enemy-flag enable-on-active checking-water))
+       (logclear! (-> obj mask) (process-mask collectable))
+       (logclear! (-> obj enemy-flags) (enemy-flag look-at-move-dest))
+       (logclear! (-> obj mask) (process-mask actor-pause))
+       (logclear! (-> obj enemy-flags) (enemy-flag notice))
+       (send-event (handle->process (-> obj master-handle)) 'notify 'arrest #f)
+       (go (method-of-object obj arrested))
+       )
+      (('attack)
+       ((method-of-type bot enemy-method-74) obj arg0 arg1 arg2 arg3)
+       #f
+       )
+      (else
+        ((method-of-type bot enemy-method-74) obj arg0 arg1 arg2 arg3)
+        )
+      )
+    )
+  )
+
+;; definition for method 97 of type kid
+(defmethod enemy-method-97 kid ((obj kid))
+  (with-pp
+    (let* ((s4-0 (handle->process (-> obj attacker-handle)))
+           (s5-0 (if (type? s4-0 process-focusable)
+                     s4-0
+                     )
+                 )
+           (s3-0 (handle->process (-> obj arrestor-handle)))
+           (s4-1 (if (type? s3-0 process-focusable)
+                     s3-0
+                     )
+                 )
+           )
+      (when s5-0
+        (cond
+          ((= (-> s5-0 type) target)
+           (when (or (not (logtest? (-> obj bot-flags) (bot-flags attacked)))
+                     (>= (- (-> pp clock frame-counter) (-> obj attacker-time)) (seconds 1.5))
+                     )
+             (if (logtest? (-> obj bot-flags) (bot-flags attacked))
+                 (reset-attacker! obj)
+                 )
+             (set! s5-0 (the-as process #f))
+             (set! (-> obj attacker-handle) (the-as handle #f))
+             )
+           )
+          (else
+            (when (>= (- (-> pp clock frame-counter) (-> obj attacker-time)) (seconds 6))
+              (set! s5-0 (the-as process #f))
+              (set! (-> obj attacker-handle) (the-as handle #f))
+              )
+            )
+          )
+        )
+      (when s4-1
+        (when (or (>= (- (-> pp clock frame-counter) (-> obj arrest-attempt-time)) (seconds 0.5))
+                  (logtest? (-> (the-as process-focusable s4-1) focus-status) (focus-status dead hit))
+                  )
+          (set! s4-1 (the-as process #f))
+          (set! (-> obj arrestor-handle) (the-as handle #f))
+          )
+        )
+      (let ((v1-34 (-> obj focus-mode))
+            (s3-1 (the-as process #f))
+            )
+        (cond
+          ((zero? v1-34)
+           (cond
+             (s4-1
+               (set! s3-1 s4-1)
+               )
+             (s5-0
+               (set! s3-1 s5-0)
+               )
+             ((begin (set! s3-1 (select-focus! obj)) s3-1)
+              (empty)
+              )
+             (else
+               (let ((s5-1 (handle->process (-> obj poi-handle))))
+                 (set! s3-1 (if (type? s5-1 process-focusable)
+                                s5-1
+                                )
+                       )
+                 )
+               (if s3-1
+                   (empty)
+                   (set! s3-1 *target*)
+                   )
+               )
+             )
+           )
+          ((= v1-34 1)
+           (cond
+             (s4-1
+               (set! s3-1 s4-1)
+               )
+             (s5-0
+               (set! s3-1 s5-0)
+               )
+             (else
+               (let ((s5-2 (handle->process (-> obj poi-handle))))
+                 (set! s3-1 (if (type? s5-2 process-focusable)
+                                s5-2
+                                )
+                       )
+                 )
+               (cond
+                 (s3-1
+                   (empty)
+                   )
+                 ((begin (set! s3-1 (select-focus! obj)) s3-1)
+                  (empty)
+                  )
+                 (else
+                   (set! s3-1 *target*)
+                   )
+                 )
+               )
+             )
+           )
+          )
+        (cond
+          (s3-1
+            (try-update-focus (-> obj focus) (the-as process-focusable s3-1) obj)
+            (if (and (logtest? (-> obj bot-flags) (bot-flags attacked)) (!= (-> s3-1 type) target))
+                (logclear! (-> obj bot-flags) (bot-flags attacked))
+                )
+            )
+          (else
+            (clear-focused (-> obj focus))
+            (logclear! (-> obj bot-flags) (bot-flags attacked))
+            )
+          )
+        s3-1
+        )
+      )
+    )
+  )
+
+;; definition for method 183 of type kid
+(defmethod alive? kid ((obj kid))
+  (let ((t9-0 (method-of-type bot alive?)))
+    (and (t9-0 obj)
+         (not (and (-> obj next-state) (let ((v1-4 (-> obj next-state name)))
+                                         (or (= v1-4 'arrested) (= v1-4 'die) (= v1-4 'die-falling))
+                                         )
+                   )
+              )
+         (zero? (logand (bot-flags bf20) (-> obj bot-flags)))
+         )
+    )
+  )
+
+;; definition for method 114 of type kid
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-114 kid ((obj kid))
+  "@abstract"
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum hit-by-others))))
+    (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 3) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 4))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec bot bot-targetable))
+      (set! (-> s4-0 prim-core collide-with)
+            (collide-spec backgnd jak crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
+            )
+      (set! (-> s4-0 prim-core action) (collide-action solid can-ride no-standon))
+      (set-vector! (-> s4-0 local-sphere) 0.0 3276.8 0.0 4505.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 bot bot-targetable))
+      (set! (-> v1-13 prim-core collide-with)
+            (collide-spec backgnd jak crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-13 prim-core action) (collide-action solid can-ride))
+      (set-vector! (-> v1-13 local-sphere) 0.0 2048.0 0.0 2048.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 bot bot-targetable))
+      (set! (-> v1-15 prim-core collide-with)
+            (collide-spec backgnd jak crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-15 prim-core action) (collide-action solid))
+      (set-vector! (-> v1-15 local-sphere) 0.0 3584.0 0.0 2048.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 bot bot-targetable))
+      (set! (-> v1-17 prim-core collide-with)
+            (collide-spec backgnd jak crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-17 prim-core action) (collide-action solid no-standon))
+      (set-vector! (-> v1-17 local-sphere) 0.0 5120.0 0.0 2048.0)
+      )
+    (set! (-> s5-0 nav-radius) 3481.6)
+    (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! (-> s5-0 max-iteration-count) (the-as uint 3))
+    (set! (-> s5-0 event-priority) (the-as uint 3))
+    (set! (-> obj root-override2) s5-0)
+    )
+  0
+  (none)
+  )
+
+;; definition for method 210 of type kid
+;; WARN: Return type mismatch int vs none.
+(defmethod init! kid ((obj kid))
+  "Set defaults for various fields."
+  (let ((t9-0 (method-of-type bot init!)))
+    (t9-0 obj)
+    )
+  (set! (-> obj min-speed) 6144.0)
+  (set! (-> obj max-speed) 22528.0)
+  (set! (-> obj channel) (the-as uint 26))
+  (set! (-> obj notice-enemy-dist) 122880.0)
+  (set! (-> obj travel-anim-interp) 0.0)
+  (set! (-> obj focus-info max-los-dist) 0.0)
+  (set-vector! (-> obj root-override2 scale) 1.2 1.2 1.2 1.0)
+  (set! (-> obj spot-color) (the-as uint #x60004f8f))
+  (set! (-> obj arrestor-handle) (the-as handle #f))
+  0
+  (none)
+  )
+
+;; definition for method 115 of type kid
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-115 kid ((obj kid))
+  "@abstract"
+  (init! obj)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-kid" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (enemy-method-113 obj *kid-nav-enemy-info*)
+  (let ((v1-7 (-> obj neck)))
+    (set! (-> v1-7 up) (the-as uint 1))
+    (set! (-> v1-7 nose) (the-as uint 2))
+    (set! (-> v1-7 ear) (the-as uint 0))
+    (set-vector! (-> v1-7 twist-max) 11832.889 11832.889 0.0 1.0)
+    (set! (-> v1-7 ignore-angle) 30947.555)
+    )
+  (let ((t9-4 (method-of-type bot enemy-method-115)))
+    (t9-4 obj)
+    )
+  (set! (-> obj my-simple-focus) (process-spawn simple-focus :to obj))
+  0
+  (none)
+  )
+
+;; definition for method 214 of type kid
+(defmethod bot-method-214 kid ((obj kid))
+  #f
+  )
+
+;; definition for method 70 of type kid
+(defmethod go-hostile kid ((obj kid))
+  (kid-method-232 obj)
+  (none)
+  )
+
+;; definition for method 72 of type kid
+(defmethod enemy-method-72 kid ((obj kid))
+  (kid-method-232 obj)
+  (none)
+  )
+
+;; definition for method 233 of type kid
+;; WARN: Return type mismatch object vs none.
+(defmethod kid-method-233 kid ((obj kid))
+  (go (method-of-object obj waiting-turn))
+  (none)
+  )
+
+;; definition for method 232 of type kid
+;; WARN: Return type mismatch object vs none.
+(defmethod kid-method-232 kid ((obj kid))
+  (let ((s5-0 (handle->process (-> obj arrestor-handle))))
+    (cond
+      ((if (type? s5-0 process-focusable)
+           s5-0
+           )
+       (go (method-of-object obj arrested))
+       )
+      ((logtest? (bot-flags bf19) (-> obj bot-flags))
+       (go (method-of-object obj scared-idle))
+       )
+      (else
+        (go (method-of-object obj waiting-idle))
+        )
+      )
+    )
+  (none)
+  )
+
+;; definition for method 234 of type kid
+;; WARN: Return type mismatch int vs none.
+(defmethod kid-method-234 kid ((obj kid))
+  (with-pp
+    (let ((f30-0 (-> obj nav state speed)))
+      (let ((f0-1 (lerp-scale 0.0 1.0 f30-0 6144.0 22528.0)))
+        (seek! (-> obj travel-anim-interp) f0-1 (* 4.0 (-> pp clock seconds-per-frame)))
+        )
+      (let ((f28-0 (-> obj travel-anim-interp))
+            (v1-7 (if (> (-> obj skel active-channels) 0)
+                      (-> obj skel root-channel 0 frame-group)
+                      )
+                  )
+            )
+        (cond
+          ((and v1-7 (= v1-7 (-> obj draw art-group data 5)))
+           (let ((v1-12 (-> obj skel root-channel 1)))
+             (set! (-> v1-12 frame-interp 1) f28-0)
+             (set! (-> v1-12 frame-interp 0) f28-0)
+             )
+           (let* ((f28-1 (current-cycle-distance (-> obj skel)))
+                  (f0-5 (quaternion-y-angle (-> obj root-override2 quat)))
+                  (f1-2 (deg- f0-5 (-> obj travel-prev-ry)))
+                  (f0-8 (fmin 22528.0 (* 0.35342914 (-> pp clock frames-per-second) (fabs f1-2))))
+                  (f0-11 (/ (* 8.0 (fmax f30-0 f0-8)) (* 15.0 f28-1)))
+                  (a0-10 (-> obj skel root-channel 0))
+                  )
+             (set! (-> a0-10 param 0) f0-11)
+             (joint-control-channel-group-eval! a0-10 (the-as art-joint-anim #f) num-func-loop!)
+             )
+           (let ((a0-11 (-> obj skel root-channel 1)))
+             (set! (-> a0-11 param 0) 0.0)
+             (joint-control-channel-group-eval! a0-11 (the-as art-joint-anim #f) num-func-chan)
+             )
+           )
+          (else
+            (ja-channel-push! 2 (seconds 0.15))
+            (let ((a0-13 (-> obj skel root-channel 0)))
+              (set! (-> a0-13 dist) 3276.8)
+              (set! (-> a0-13 frame-group) (the-as art-joint-anim (-> obj draw art-group data 5)))
+              (set! (-> a0-13 param 0) 1.0)
+              (joint-control-channel-group! a0-13 (the-as art-joint-anim (-> obj draw art-group data 5)) num-func-loop!)
+              )
+            (let ((a0-14 (-> obj skel root-channel 1)))
+              (set! (-> a0-14 frame-interp 1) f28-0)
+              (set! (-> a0-14 frame-interp 0) f28-0)
+              (set! (-> a0-14 dist) 8737.997)
+              (set! (-> a0-14 frame-group) (the-as art-joint-anim (-> obj draw art-group data 6)))
+              (set! (-> a0-14 param 0) 0.0)
+              (joint-control-channel-group! a0-14 (the-as art-joint-anim (-> obj draw art-group data 6)) num-func-chan)
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  )
+
+;; definition for method 56 of type kid
+(defmethod enemy-method-56 kid ((obj kid) (arg0 process) (arg1 event-message-block))
+  (if (= (-> obj course course-id) 7)
+      0
+      ((method-of-type bot enemy-method-56) obj arg0 arg1)
+      )
+  )
+
+;; definition for method 190 of type kid
+(defmethod bot-method-190 kid ((obj kid))
+  #t
+  )
+
+;; definition for method 78 of type kid
+(defmethod enemy-method-78 kid ((obj kid) (arg0 (pointer float)))
+  (ja-channel-push! 1 (seconds 0.1))
+  (let ((a1-2 (-> obj draw art-group data (-> obj enemy-info-override knocked-land-anim)))
+        (a0-4 (-> obj skel root-channel 0))
+        )
+    (set! (-> a0-4 frame-group) (the-as art-joint-anim a1-2))
+    (set! (-> a0-4 param 0) (the float (+ (-> (the-as art-joint-anim a1-2) 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-2) num-func-seek!)
+    )
+  #t
+  )
+
+;; definition for method 198 of type kid
+;; WARN: Return type mismatch float vs meters.
+(defmethod set-cam-height! kid ((obj kid) (arg0 vector))
+  (the-as
+    meters
+    (cond
+      ((and (-> obj next-state) (= (-> obj next-state name) 'arrested))
+       (set-vector! arg0 49152.0 12288.0 49152.0 1.0)
+       (vector<-cspace+vector! arg0 (-> obj node-list data 2) arg0)
+       (if (logtest? (-> obj focus-status) (focus-status under-water))
+           (set! (-> arg0 y) (+ (get-water-height obj) (-> *setting-control* cam-current target-height)))
+           )
+       )
+      (else
+        ((method-of-type bot set-cam-height!) obj arg0)
+        )
+      )
+    )
+  )
+
+;; definition for method 102 of type kid
+(defmethod enemy-method-102 kid ((obj kid))
+  (if (logtest? (bot-flags bf20) (-> obj bot-flags))
+      #f
+      ((method-of-type bot enemy-method-102) obj)
+      )
+  )
+
+;; definition for method 116 of type kid
+;; WARN: Return type mismatch object vs none.
+(defmethod go-idle kid ((obj kid))
+  (cond
+    ((= (-> obj course course-id) 7)
+     (cond
+       ((task-node-closed? (game-task-node city-help-kid-resolution))
+        (cleanup-for-death obj)
+        (go (method-of-object obj die-fast))
+        )
+       (else
+         (go (method-of-object obj waiting-with-kor))
+         )
+       )
+     )
+    (else
+      (go (method-of-object obj waiting-idle))
+      )
+    )
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/city/slums/kor/kor-h_REF.gc b/test/decompiler/reference/jak2/levels/city/slums/kor/kor-h_REF.gc
new file mode 100644
index 0000000000..684763c650
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/city/slums/kor/kor-h_REF.gc
@@ -0,0 +1,85 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type kor
+(deftype kor (bot)
+  ((travel-anim-interp  float       :offset-assert 992)
+   (arrest-attempt-time time-frame  :offset-assert 1000)
+   (arrestor-handle     handle      :offset-assert 1008)
+   )
+  :heap-base #x380
+  :method-count-assert 235
+  :size-assert         #x3f8
+  :flag-assert         #xeb038003f8
+  (:methods
+    (traveling () _type_ :state 225)
+    (traveling-blocked () _type_ :state 226)
+    (waiting-with-kid () _type_ :state 227)
+    (waiting-idle () _type_ :state 228)
+    (waiting-turn () _type_ :state 229)
+    (scared-idle () _type_ :state 230)
+    (arrested () _type_ :state 231)
+    (kor-method-232 (_type_) none 232)
+    (kor-method-233 (_type_) none 233)
+    (kor-method-234 (_type_) none 234)
+    )
+  )
+
+;; definition for method 3 of type kor
+(defmethod inspect kor ((obj kor))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type bot inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Ttravel-anim-interp: ~f~%" (-> obj travel-anim-interp))
+  (format #t "~2Tarrest-attempt-time: ~D~%" (-> obj arrest-attempt-time))
+  (format #t "~2Tarrestor-handle: ~D~%" (-> obj arrestor-handle))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-kor kor kor-lod0-jg kor-idle0-ja
+              ((kor-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 2.5)
+              :shadow kor-shadow-mg
+              :origin-joint-index 13
+              )
+
+;; definition of type kort-wait-spot
+(deftype kort-wait-spot (ai-task)
+  ((check-done   (function kort-wait-spot kor symbol)   :offset  32)
+   (which-spot   int8                                   :offset  36)
+   (num-spots    uint8                                  :offset  37)
+   (spot-indexes uint8                                6 :offset  38)
+   )
+  :method-count-assert 12
+  :size-assert         #x30
+  :flag-assert         #xc00000030
+  )
+
+;; definition for method 3 of type kort-wait-spot
+(defmethod inspect kort-wait-spot ((obj kort-wait-spot))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj (-> obj type))
+  (format #t "~1Tnext: ~A~%" (-> obj next))
+  (format #t "~1Tprev: ~A~%" (-> obj prev))
+  (format #t "~1Tpool: ~A~%" (-> obj pool))
+  (format #t "~1Tunique-id: ~D~%" (-> obj unique-id))
+  (format #t "~1Tbytes[16] @ #x~X~%" (-> obj bytes))
+  (format #t "~1Tcheck-done: ~A~%" (-> obj check-done))
+  (format #t "~1Twhich-spot: ~D~%" (-> obj which-spot))
+  (format #t "~1Tnum-spots: ~D~%" (-> obj num-spots))
+  (format #t "~1Tspot-indexes[6] @ #x~X~%" (-> obj spot-indexes))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+0
diff --git a/test/decompiler/reference/jak2/levels/city/slums/kor/kor-states_REF.gc b/test/decompiler/reference/jak2/levels/city/slums/kor/kor-states_REF.gc
new file mode 100644
index 0000000000..ea607e44b4
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/city/slums/kor/kor-states_REF.gc
@@ -0,0 +1,684 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; failed to figure out what this is:
+(defstate waiting-idle (kor)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kor) 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
+    (nav-enemy-method-167 self)
+    (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))
+    (enemy-method-109 self 1)
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (b!
+      (not (and (-> self focus-info fproc) (>= (fabs (-> self focus-info ry-diff)) 9102.223)))
+      cfg-6
+      :delay (empty-form)
+      )
+    (kor-method-233 self)
+    (b! #t cfg-15 :delay (nop!))
+    (label cfg-6)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (if (if (type? gp-0 process-focusable)
+              gp-0
+              )
+          (go-virtual arrested)
+          )
+      )
+    (label cfg-15)
+    (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+      (if (not (outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #f))
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((v1-2 (ja-group)))
+      (cond
+        ((and v1-2 (= v1-2 (-> self draw art-group data 3)))
+         (ja-no-eval :num! (seek!))
+         (while (not (ja-done? 0))
+           (suspend)
+           (ja-eval)
+           )
+         )
+        (else
+          (ja-channel-push! 1 (seconds 0.2))
+          )
+        )
+      )
+    (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 (the-as (function none :behavior kor) nav-enemy-simple-post)
+  )
+
+;; failed to figure out what this is:
+(defstate waiting-turn (kor)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kor) 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
+    (nav-enemy-method-167 self)
+    (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))
+    (enemy-method-109 self 1)
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+      (if (and (not (outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #f))
+               (let ((gp-0 (handle->process (-> self arrestor-handle))))
+                 (not (if (type? gp-0 process-focusable)
+                          gp-0
+                          )
+                      )
+                 )
+               )
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (local-vars (s4-1 art-element) (f0-9 float))
+    (let ((gp-0 (new 'stack-no-clear 'bot-turn-info)))
+      (let ((s5-0 (-> self focus-info fproc)))
+        (if (not s5-0)
+            (kor-method-232 self)
+            )
+        (turn-to-target self gp-0 s5-0 1.867)
+        )
+      (let ((s4-0 (>= (-> gp-0 predicted-ry-diff) 0.0)))
+        (let ((s5-1 (-> self draw art-group data (if s4-0
+                                                     7
+                                                     11
+                                                     )
+                        )
+                    )
+              )
+          (ja-channel-push! 1 (seconds 0.2))
+          (ja-no-eval :group! s5-1
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim s5-1) frames num-frames) -1)))
+                      :frame-num 0.0
+                      )
+          )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek!))
+          )
+        (let ((a2-3 (-> self focus-info fproc)))
+          (if a2-3
+              (turn-to-target self gp-0 a2-3 1.6)
+              )
+          )
+        (let ((s5-2 (new 'stack-no-clear 'quaternion))
+              (f0-8 (-> gp-0 predicted-ry-diff))
+              (f30-0 4.0)
+              (f28-0 5.0)
+              )
+          (set! f28-0 (cond
+                        (s4-0
+                          (if (< f0-8 0.0)
+                              (set! f0-8 (+ 65536.0 f0-8))
+                              )
+                          (cond
+                            ((< f0-8 18204.445)
+                             (set! f0-9 9102.223)
+                             (set! s4-1 (-> self draw art-group data 8))
+                             (set! f30-0 5.0)
+                             14.0
+                             )
+                            ((< f0-8 27306.666)
+                             (set! f0-9 18204.445)
+                             (set! s4-1 (-> self draw art-group data 9))
+                             (set! f30-0 5.0)
+                             23.0
+                             )
+                            (else
+                              (set! f0-9 27306.666)
+                              (set! s4-1 (-> self draw art-group data 10))
+                              (set! f30-0 5.0)
+                              23.0
+                              )
+                            )
+                          )
+                        (else
+                          (if (>= f0-8 0.0)
+                              (set! f0-8 (+ -65536.0 f0-8))
+                              )
+                          (cond
+                            ((< -18204.445 f0-8)
+                             (set! f0-9 -9102.223)
+                             (set! s4-1 (-> self draw art-group data 12))
+                             )
+                            ((< -27306.666 f0-8)
+                             (set! f0-9 -18204.445)
+                             (set! s4-1 (-> self draw art-group data 13))
+                             (set! f30-0 5.0)
+                             (set! f28-0 23.0)
+                             )
+                            (else
+                              (set! f0-9 -27306.666)
+                              (set! s4-1 (-> self draw art-group data 14))
+                              (set! f30-0 5.0)
+                              (set! f28-0 23.0)
+                              )
+                            )
+                          f28-0
+                          )
+                        )
+                )
+          (quaternion-rotate-y! s5-2 (-> gp-0 src-quat) f0-9)
+          (ja-no-eval :group! s4-1
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim s4-1) frames num-frames) -1)))
+                      :frame-num 0.0
+                      )
+          (until (ja-done? 0)
+            (let ((f0-14 (ja-aframe-num 0)))
+              (cond
+                ((< f0-14 f28-0)
+                 (if (>= f0-14 f30-0)
+                     (quaternion-slerp! (-> self root-override2 quat) (-> gp-0 src-quat) s5-2 (/ (- f0-14 f30-0) (- f28-0 f30-0)))
+                     )
+                 )
+                (else
+                  (quaternion-copy! (-> self root-override2 quat) s5-2)
+                  )
+                )
+              )
+            (suspend)
+            (ja :num! (seek!))
+            )
+          )
+        )
+      )
+    (kor-method-232 self)
+    (none)
+    )
+  :post (the-as (function none :behavior kor) nav-enemy-simple-post)
+  )
+
+;; failed to figure out what this is:
+(defstate waiting-with-kid (kor)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kor) enemy-event-handler)
+  :enter (-> (method-of-type kor waiting-idle) enter)
+  :exit (-> (method-of-type kor waiting-idle) exit)
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+      (if (not (outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #f))
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (-> (method-of-type kor waiting-idle) code)
+  :post (-> (method-of-type kor waiting-idle) post)
+  )
+
+;; failed to figure out what this is:
+(defstate scared-idle (kor)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kor) 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
+    (nav-enemy-method-167 self)
+    (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))
+    (enemy-method-109 self 1)
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (b!
+      (not (and (-> self focus-info fproc) (>= (fabs (-> self focus-info ry-diff)) 9102.223)))
+      cfg-6
+      :delay (empty-form)
+      )
+    (kor-method-233 self)
+    (b! #t cfg-15 :delay (nop!))
+    (label cfg-6)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (if (if (type? gp-0 process-focusable)
+              gp-0
+              )
+          (go-virtual arrested)
+          )
+      )
+    (label cfg-15)
+    (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+      (if (not (outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #f))
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((v1-2 (ja-group)))
+      (cond
+        ((and v1-2 (= v1-2 (-> self draw art-group data 4)))
+         (ja-no-eval :num! (seek!))
+         (while (not (ja-done? 0))
+           (suspend)
+           (ja-eval)
+           )
+         )
+        (else
+          (ja-channel-push! 1 (seconds 0.2))
+          )
+        )
+      )
+    (until #f
+      (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!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior kor) nav-enemy-simple-post)
+  )
+
+;; failed to figure out what this is:
+(defstate traveling (kor)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kor) enemy-event-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (let ((v1-2 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-2 enemy-flags)))
+          (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-2 enemy-flags))))
+          )
+      (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-2 enemy-flags))))
+      (set! (-> v1-2 nav callback-info) (-> v1-2 enemy-info-override callback-info))
+      )
+    0
+    (let ((v1-5 self))
+      (set! (-> v1-5 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-5 enemy-flags))))
+      )
+    0
+    (enemy-method-110 self)
+    (nav-enemy-method-166 self)
+    (set! (-> self player-blocking) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (cond
+        ((if (type? gp-0 process-focusable)
+             gp-0
+             )
+         (go-virtual arrested)
+         )
+        ((outside-spot-radius? self (the-as bot-spot #f) (the-as vector #f) #t)
+         (kor-method-232 self)
+         )
+        ((and (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.5)) (bot-method-208 self))
+         (go-virtual traveling-blocked)
+         )
+        ((and (nav-enemy-method-163 self)
+              (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+              )
+         (go-stare2 self)
+         )
+        )
+      )
+    0
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (kor-method-234 self)
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (let ((a0-0 (-> self nav state))
+          (v1-1 (-> self spot))
+          )
+      (logclear! (-> a0-0 flags) (nav-state-flag directional-mode))
+      (logior! (-> a0-0 flags) (nav-state-flag target-poly-dirty))
+      (set! (-> a0-0 target-post quad) (-> v1-1 center quad))
+      )
+    0
+    (nav-enemy-travel-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate traveling-blocked (kor)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kor) 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
+    (nav-enemy-method-167 self)
+    (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))
+    (enemy-method-109 self 1)
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (cond
+        ((if (type? gp-0 process-focusable)
+             gp-0
+             )
+         (go-virtual arrested)
+         )
+        ((and (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1)) (not (bot-method-208 self)))
+         (go-virtual traveling)
+         )
+        )
+      )
+    (none)
+    )
+  :code (-> (method-of-type kor waiting-idle) code)
+  :post (the-as (function none :behavior kor) nav-enemy-simple-post)
+  )
+
+;; failed to figure out what this is:
+(defstate stare (kor)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type bot stare) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (let ((v1-4 self))
+      (set! (-> v1-4 enemy-flags) (the-as enemy-flag (logclear (-> v1-4 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (bot-method-223 self #f)
+    (let ((gp-0 (handle->process (-> self arrestor-handle))))
+      (if (if (type? gp-0 process-focusable)
+              gp-0
+              )
+          (go-virtual arrested)
+          )
+      )
+    (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1))
+      (if (not (nav-enemy-method-163 self))
+          (go-virtual traveling)
+          )
+      )
+    (none)
+    )
+  :code (-> (method-of-type kor waiting-idle) code)
+  )
+
+;; failed to figure out what this is:
+(defstate hit (kor)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type bot hit) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  :code (behavior ()
+    (local-vars (v1-31 enemy-flag) (v1-39 enemy-flag))
+    (ja-channel-push! 1 (seconds 0.1))
+    (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!))
+      )
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (let ((v1-30 (-> self enemy-flags)))
+      (if (logtest? v1-30 (enemy-flag checking-water))
+          (set! v1-31 (logior v1-30 (enemy-flag enable-on-active)))
+          (set! v1-31 (logclear v1-30 (enemy-flag enable-on-active)))
+          )
+      )
+    (set! (-> self enemy-flags) v1-31)
+    (if (logtest? (-> self enemy-flags) (enemy-flag look-at-move-dest))
+        (set! (-> self mask) (logior (process-mask collectable) (-> self mask)))
+        (logclear! (-> self mask) (process-mask collectable))
+        )
+    (let ((v1-38 (-> self enemy-flags)))
+      (if (logtest? (enemy-flag no-initial-move-to-ground) v1-38)
+          (set! v1-39 (logior (enemy-flag check-water-backup) v1-38))
+          (set! v1-39 (logclear v1-38 (enemy-flag check-water-backup)))
+          )
+      )
+    (set! (-> self enemy-flags) v1-39)
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (logclear! (-> self focus-status) (focus-status hit))
+    (enemy-method-72 self)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate knocked (kor)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type bot knocked) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self travel-anim-interp) 0.0)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate arrested (kor)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior kor) 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
+    (nav-enemy-method-167 self)
+    (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))
+    (enemy-method-110 self)
+    (set! (-> self travel-anim-interp) 0.0)
+    (if (logtest? (bot-flags bf20) (-> self bot-flags))
+        (logclear! (-> self enemy-flags) (enemy-flag enable-on-active checking-water))
+        )
+    (none)
+    )
+  :trans (behavior ()
+    (cond
+      ((logtest? (-> self bot-flags) (bot-flags bf09))
+       (fail-falling self)
+       )
+      (else
+        (bot-method-223 self #f)
+        (when (not (logtest? (bot-flags bf20) (-> self bot-flags)))
+          (if (and (-> self focus-info fproc) (>= (fabs (-> self focus-info ry-diff)) 9102.223))
+              (kor-method-233 self)
+              )
+          (when (not (logtest? (-> self focus-status) (focus-status grabbed)))
+            (let ((gp-0 (handle->process (-> self arrestor-handle))))
+              (if (not (if (type? gp-0 process-focusable)
+                           gp-0
+                           )
+                       )
+                  (enemy-method-72 self)
+                  )
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.25))
+    (cond
+      ((and (not (logtest? (bot-flags bf20) (-> self bot-flags)))
+            (< (- (-> self clock frame-counter) (-> self arrest-attempt-time)) (seconds 0.8))
+            )
+       (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!))
+         )
+       )
+      (else
+        (ja-no-eval :group! (-> self draw art-group data 4) :num! (seek! (ja-aframe 8.0 0)) :frame-num 0.0)
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek! (ja-aframe 8.0 0)))
+          )
+        )
+      )
+    (fail-mission! self)
+    (let* ((gp-2 (handle->process (-> self arrestor-handle)))
+           (v1-49 (if (type? gp-2 process-focusable)
+                      gp-2
+                      )
+                  )
+           )
+      (if v1-49
+          (logclear! (-> (the-as crimson-guard v1-49) enemy-flags) (enemy-flag enable-on-active checking-water))
+          )
+      )
+    (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 (ja-aframe 4.0 0)
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (until #f
+      (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)
+        (if (and (logtest? (-> self bot-flags) (bot-flags failed))
+                 (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 3))
+                 (reset? *fail-mission-control*)
+                 )
+            (reset! *fail-mission-control*)
+            )
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior kor) nav-enemy-simple-post)
+  )
+
+;; failed to figure out what this is:
+(defstate failed (kor)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self bot-flags) (logior (bot-flags bf20) (-> self bot-flags)))
+    ((-> (method-of-type kor arrested) enter))
+    (none)
+    )
+  :trans (-> (method-of-type kor arrested) trans)
+  :code (-> (method-of-type kor arrested) code)
+  :post (-> (method-of-type kor arrested) post)
+  )
+
+;; failed to figure out what this is:
+(defstate die-falling (kor)
+  :virtual #t
+  :enter (-> (method-of-type kor failed) enter)
+  :trans (-> (method-of-type kor failed) trans)
+  :code (-> (method-of-type kor failed) code)
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak2/levels/city/slums/kor/kor-task_REF.gc b/test/decompiler/reference/jak2/levels/city/slums/kor/kor-task_REF.gc
new file mode 100644
index 0000000000..5ad2ad5b8a
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/city/slums/kor/kor-task_REF.gc
@@ -0,0 +1,51 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for method 9 of type kort-wait-spot
+;; WARN: Return type mismatch int vs none.
+(defmethod reset-task! kort-wait-spot ((obj kort-wait-spot))
+  "Virtual"
+  (set! (-> obj check-done) #f)
+  (set! (-> obj which-spot) -1)
+  (set! (-> obj num-spots) (the-as uint 0))
+  0
+  (none)
+  )
+
+;; definition for method 11 of type kort-wait-spot
+;; WARN: Return type mismatch symbol vs none.
+(defmethod ai-task-method-11 kort-wait-spot ((obj kort-wait-spot) (arg0 bot))
+  "Virtual"
+  (let ((s4-0 (-> obj which-spot)))
+    (when (>= s4-0 0)
+      (let ((s3-0 (-> arg0 course spots (-> obj spot-indexes s4-0))))
+        (if (and (not (outside-spot-radius? arg0 s3-0 (the-as vector #f) #f)) (player-blocking-spot? arg0 s3-0))
+            (set! s4-0 -1)
+            )
+        )
+      )
+    (when (< s4-0 0)
+      (set! s4-0 (choose-spot arg0 (the-as int (-> obj num-spots)) (the-as (pointer uint) (-> obj spot-indexes))))
+      (set! (-> obj which-spot) s4-0)
+      (mem-copy!
+        (the-as pointer (-> arg0 spot))
+        (the-as pointer (-> arg0 course spots (-> obj spot-indexes s4-0)))
+        20
+        )
+      )
+    (if (logtest? *display-bot-marks* (bot-marks-controls bmc16))
+        (bot-debug-draw-spot-sphere
+          arg0
+          (the-as int (-> obj num-spots))
+          (the-as (pointer uint) (-> obj spot-indexes))
+          (the-as int (-> obj spot-indexes s4-0))
+          )
+        )
+    )
+  ((-> obj check-done) obj (the-as kor arg0))
+  (none)
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak2/levels/city/slums/kor/kor3-course_REF.gc b/test/decompiler/reference/jak2/levels/city/slums/kor/kor3-course_REF.gc
new file mode 100644
index 0000000000..6c5a3eae6f
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/city/slums/kor/kor3-course_REF.gc
@@ -0,0 +1,236 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for function kor-update-during-battle
+;; WARN: Return type mismatch focus-status vs none.
+(defun kor-update-during-battle ((arg0 kor))
+  (let ((v1-0 *target*))
+    (if (and v1-0 (-> v1-0 next-state) (let ((v1-3 (-> v1-0 next-state name)))
+                                         (or (= v1-3 'target-darkjak-get-on) (= v1-3 'target-darkjak-get-off))
+                                         )
+             )
+        (logior! (-> arg0 focus-status) (focus-status disable))
+        (logclear! (-> arg0 focus-status) (focus-status disable))
+        )
+    )
+  (none)
+  )
+
+;; definition for symbol *kor3-course*, type bot-course
+(define *kor3-course*
+  (new 'static 'bot-course
+    :course-id #x8
+    :spot-count #x4
+    :default-check-too-far #f
+    :waypoints (new 'static 'boxed-array :type bot-waypoint
+      (new 'static 'bot-waypoint
+        :waypoint-id 1
+        :skip-to -1
+        :on-set (lambda ((arg0 kor))
+          (process-entity-status! arg0 (entity-perm-status no-kill) #t)
+          (clear-speech-flags! arg0)
+          (logior! (-> arg0 focus-status) (focus-status disable))
+          (set! (-> arg0 notice-enemy-dist) 0.0)
+          (let ((v1-5 (-> arg0 root-override2 root-prim)))
+            (set! (-> v1-5 prim-core collide-as) (collide-spec))
+            (set! (-> v1-5 prim-core collide-with) (collide-spec))
+            )
+          0
+          (move-to-point! (-> arg0 root-override2) (the-as vector (-> arg0 course spots 0)))
+          (logclear! (-> arg0 mask) (process-mask actor-pause))
+          (logclear! (-> arg0 enemy-flags) (enemy-flag notice))
+          (let ((v1-16 (get-task-by-type (-> arg0 ai-ctrl) kort-wait-spot arg0)))
+            (set! (-> v1-16 bytes 5) (the-as uint 1))
+            (set! (-> v1-16 bytes 6) (the-as uint 0))
+            (set! (-> v1-16 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kort-wait-spot v1-16) check-done)
+                  (the-as
+                    (function kort-wait-spot kor symbol)
+                    (lambda ((arg0 object) (arg1 kor)) (when (< 1 (-> arg1 waypoint-request))
+                                                         (let* ((v1-4 (-> arg1 actor-group 0 data 0 actor))
+                                                                (a0-2 (if v1-4
+                                                                          (-> v1-4 extra process)
+                                                                          )
+                                                                      )
+                                                                )
+                                                           (when a0-2
+                                                             (set! (-> arg1 master-handle) (process->handle a0-2))
+                                                             (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                                                             (go-to-waypoint! arg1 2 #f)
+                                                             (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                                                             #t
+                                                             )
+                                                           )
+                                                         )
+                            )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update #f
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 2
+        :skip-to -1
+        :on-set (lambda ((arg0 kor))
+          (let ((v1-1 (-> arg0 root-override2 root-prim)))
+            (set! (-> v1-1 prim-core collide-as) (-> arg0 root-override2 backup-collide-as))
+            (set! (-> v1-1 prim-core collide-with) (-> arg0 root-override2 backup-collide-with))
+            )
+          (logclear! (-> arg0 focus-status) (focus-status disable))
+          (let ((v1-5 (get-task-by-type (-> arg0 ai-ctrl) kort-wait-spot arg0)))
+            (set! (-> v1-5 bytes 5) (the-as uint 1))
+            (set! (-> v1-5 bytes 6) (the-as uint 0))
+            (set! (-> v1-5 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kort-wait-spot v1-5) check-done)
+                  (the-as
+                    (function kort-wait-spot kor symbol)
+                    (lambda ((arg0 object) (arg1 kor))
+                      (when (>= (-> arg1 waypoint-request) 6)
+                        (set! (-> arg1 root-override2 trans quad) (-> arg1 course spots 1 center quad))
+                        (set! (-> arg1 root-override2 trans w) 1.0)
+                        (quaternion-vector-angle!
+                          (-> arg1 root-override2 quat)
+                          *up-vector*
+                          (* 182.04445 (* 0.00024414062 (-> arg1 course spots 1 center w)))
+                          )
+                        (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                        (go-to-waypoint! arg1 5 #f)
+                        (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                        #t
+                        )
+                      )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update #f
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 5
+        :skip-to -1
+        :on-set (lambda ((arg0 kor))
+          (set! (-> arg0 focus-status) (logior (focus-status arrestable) (-> arg0 focus-status)))
+          (set! (-> arg0 bot-flags) (logior (bot-flags bf19) (-> arg0 bot-flags)))
+          (set! (-> arg0 notice-enemy-dist) 122880.0)
+          (let ((v1-6 (get-task-by-type (-> arg0 ai-ctrl) kort-wait-spot arg0)))
+            (set! (-> v1-6 bytes 5) (the-as uint 1))
+            (set! (-> v1-6 bytes 6) (the-as uint 2))
+            (set! (-> v1-6 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kort-wait-spot v1-6) check-done)
+                  (the-as
+                    (function kort-wait-spot kor symbol)
+                    (lambda ((arg0 object) (arg1 kor))
+                      (when (outside-spot-radius? arg1 (the-as bot-spot #f) (the-as vector #f) #f)
+                        (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                        (go-to-waypoint! arg1 6 #f)
+                        (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                        #t
+                        )
+                      )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update (lambda ((arg0 kor)) (kor-update-during-battle arg0) (none))
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 6
+        :skip-to -1
+        :on-set (lambda ((arg0 kor))
+          (let ((v1-1 (get-task-by-type (-> arg0 ai-ctrl) kort-wait-spot arg0)))
+            (set! (-> v1-1 bytes 5) (the-as uint 1))
+            (set! (-> v1-1 bytes 6) (the-as uint 3))
+            (set! (-> v1-1 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kort-wait-spot v1-1) check-done)
+                  (the-as
+                    (function kort-wait-spot kor symbol)
+                    (lambda ((arg0 object) (arg1 kor)) (when (>= (-> arg1 waypoint-request) 8)
+                                                         (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                                                         (go-to-waypoint! arg1 8 #f)
+                                                         (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                                                         #t
+                                                         )
+                            )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update (lambda ((arg0 kor)) (kor-update-during-battle arg0) (none))
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 8
+        :skip-to -1
+        :on-set (lambda ((arg0 kor))
+          (logclear! (-> arg0 focus-status) (focus-status disable arrestable))
+          (let ((v1-3 (get-task-by-type (-> arg0 ai-ctrl) kort-wait-spot arg0)))
+            (set! (-> v1-3 bytes 5) (the-as uint 1))
+            (set! (-> v1-3 bytes 6) (the-as uint 3))
+            (set! (-> v1-3 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kort-wait-spot v1-3) check-done)
+                  (the-as
+                    (function kort-wait-spot kor symbol)
+                    (lambda ((arg0 object) (arg1 kor)) (when (>= (-> arg1 waypoint-request) 10)
+                                                         (ai-task-control-method-12 (-> arg1 ai-ctrl) arg1)
+                                                         (go-to-waypoint! arg1 10 #f)
+                                                         (ai-task-control-method-10 (-> arg1 ai-ctrl) arg1)
+                                                         #t
+                                                         )
+                            )
+                    )
+                  )
+            )
+          (none)
+          )
+        :on-update #f
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      (new 'static 'bot-waypoint
+        :waypoint-id 10
+        :skip-to -1
+        :on-set (lambda ((arg0 kor))
+          (process-entity-status! arg0 (entity-perm-status bit-4) #f)
+          (send-event arg0 'die-fast)
+          (let ((v1-4 (get-task-by-type (-> arg0 ai-ctrl) kort-wait-spot arg0)))
+            (set! (-> v1-4 bytes 5) (the-as uint 1))
+            (set! (-> v1-4 bytes 6) (the-as uint 3))
+            (set! (-> v1-4 bytes 4) (the-as uint -1))
+            (set! (-> (the-as kort-wait-spot v1-4) check-done)
+                  (the-as (function kort-wait-spot kor symbol) (lambda () #f))
+                  )
+            )
+          (none)
+          )
+        :on-update #f
+        :on-skipping-here #f
+        :check-too-far #f
+        )
+      )
+    :spots (new 'static 'inline-array bot-spot 4
+      (new 'static 'bot-spot :center (new 'static 'vector :x 2604400.8 :y 32604.16 :z -375070.72 :w 10240.0))
+      (new 'static 'bot-spot :center (new 'static 'vector :x 2618215.8 :y 32768.0 :z -391537.47 :w -504556.34))
+      (new 'static 'bot-spot :center (new 'static 'vector :x 2599608.2 :y 32727.04 :z -200253.44 :w 32768.0))
+      (new 'static 'bot-spot :center (new 'static 'vector :x 2546770.0 :y 32727.04 :z -177561.6 :w 8192.0))
+      )
+    )
+  )
+
+;; failed to figure out what this is:
+(set! (-> *bot-course-table* course 8) *kor3-course*)
+
+
+
+
diff --git a/test/decompiler/reference/jak2/levels/city/slums/kor/kor_REF.gc b/test/decompiler/reference/jak2/levels/city/slums/kor/kor_REF.gc
new file mode 100644
index 0000000000..1d34f4b713
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/city/slums/kor/kor_REF.gc
@@ -0,0 +1,614 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type kor-anim-info
+(deftype kor-anim-info (structure)
+  ((anim-index int32  :offset-assert   0)
+   )
+  :method-count-assert 9
+  :size-assert         #x4
+  :flag-assert         #x900000004
+  )
+
+;; definition for method 3 of type kor-anim-info
+(defmethod inspect kor-anim-info ((obj kor-anim-info))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'kor-anim-info)
+  (format #t "~1Tanim-index: ~D~%" (-> obj anim-index))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for symbol *kor-nav-enemy-info*, type nav-enemy-info
+(define *kor-nav-enemy-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 idle-control-frame 2
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x3 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 3
+    :notice-anim 3
+    :hostile-anim -1
+    :hit-anim 3
+    :knocked-anim 15
+    :knocked-land-anim 16
+    :die-anim 3
+    :die-falling-anim 3
+    :victory-anim -1
+    :jump-wind-up-anim 3
+    :jump-in-air-anim 3
+    :jump-land-anim 3
+    :neck-joint 6
+    :look-at-joint 6
+    :bullseye-joint 4
+    :notice-distance (meters 30)
+    :notice-distance-delta (meters 10)
+    :proximity-notice-distance (meters 30)
+    :default-hit-points 100
+    :gnd-collide-with (collide-spec backgnd)
+    :overlaps-others-collide-with-filter (collide-spec jak civilian enemy vehicle-sphere hit-by-others-list player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.7
+    :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 2730.6667
+    :knocked-soft-vxz-lo 43008.0
+    :knocked-soft-vxz-hi 43008.0
+    :knocked-soft-vy-lo 79872.0
+    :knocked-soft-vy-hi 79872.0
+    :knocked-medium-vxz-lo 43008.0
+    :knocked-medium-vxz-hi 43008.0
+    :knocked-medium-vy-lo 79872.0
+    :knocked-medium-vy-hi 79872.0
+    :knocked-hard-vxz-lo 43008.0
+    :knocked-hard-vxz-hi 43008.0
+    :knocked-hard-vy-lo 79872.0
+    :knocked-hard-vy-hi 79872.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 43008.0
+    :knocked-yellow-vxz-hi 43008.0
+    :knocked-yellow-vy-lo 79872.0
+    :knocked-yellow-vy-hi 79872.0
+    :knocked-red-vxz-lo 43008.0
+    :knocked-red-vxz-hi 43008.0
+    :knocked-red-vy-lo 79872.0
+    :knocked-red-vy-hi 79872.0
+    :knocked-blue-vxz-lo 43008.0
+    :knocked-blue-vxz-hi 43008.0
+    :knocked-blue-vy-lo 79872.0
+    :knocked-blue-vy-hi 79872.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 #t
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #f
+    :use-pacing #f
+    :walk-anim 3
+    :turn-anim -1
+    :run-anim 3
+    :taunt-anim -1
+    :run-travel-speed (meters 5.1)
+    :run-acceleration (meters 5)
+    :run-turning-acceleration (meters 6)
+    :walk-travel-speed (meters 1.5)
+    :walk-acceleration (meters 5)
+    :walk-turning-acceleration (meters 6)
+    :maximum-rotation-rate (degrees 180.0)
+    :notice-nav-radius (meters 1)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :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! (-> *kor-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+;; definition for method 74 of type kor
+(defmethod enemy-method-74 kor ((obj kor) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (with-pp
+    (case arg2
+      (('arrest)
+       (let* ((s4-0 (handle->process (-> obj arrestor-handle)))
+              (v1-4 (if (type? s4-0 process-focusable)
+                        s4-0
+                        )
+                    )
+              )
+         (when (or (not v1-4)
+                   (= v1-4 arg0)
+                   (and (!= v1-4 arg0) (>= (- (-> pp clock frame-counter) (-> obj arrest-attempt-time)) (seconds 0.1)))
+                   )
+           (set! (-> obj arrestor-handle) (process->handle arg0))
+           (set! (-> obj arrest-attempt-time) (-> pp clock frame-counter))
+           0
+           )
+         )
+       #t
+       )
+      (('instant-arrest)
+       (set! (-> obj bot-flags) (logior (bot-flags bf20) (-> obj bot-flags)))
+       (let ((v1-18 (the-as object (-> arg3 param 0))))
+         (set! (-> obj arrestor-handle) (process->handle (the-as process v1-18)))
+         (set! (-> obj arrest-attempt-time) (-> pp clock frame-counter))
+         (let ((a1-8 (new 'stack-no-clear 'vector)))
+           (vector-! a1-8 (-> (the-as process-drawable v1-18) root trans) (-> obj root-override2 trans))
+           (set! (-> a1-8 y) 0.0)
+           (forward-up->quaternion (-> obj root-override2 quat) a1-8 *up-vector*)
+           )
+         )
+       (logclear! (-> obj enemy-flags) (enemy-flag enable-on-active checking-water))
+       (logclear! (-> obj mask) (process-mask collectable))
+       (logclear! (-> obj enemy-flags) (enemy-flag look-at-move-dest))
+       (logclear! (-> obj mask) (process-mask actor-pause))
+       (logclear! (-> obj enemy-flags) (enemy-flag notice))
+       (go (method-of-object obj arrested))
+       )
+      (else
+        ((method-of-type bot enemy-method-74) obj arg0 arg1 arg2 arg3)
+        )
+      )
+    )
+  )
+
+;; definition for method 97 of type kor
+(defmethod enemy-method-97 kor ((obj kor))
+  (with-pp
+    (let* ((s4-0 (handle->process (-> obj attacker-handle)))
+           (s5-0 (if (type? s4-0 process-focusable)
+                     s4-0
+                     )
+                 )
+           (s3-0 (handle->process (-> obj arrestor-handle)))
+           (s4-1 (if (type? s3-0 process-focusable)
+                     s3-0
+                     )
+                 )
+           )
+      (when s5-0
+        (cond
+          ((= (-> s5-0 type) target)
+           (when (or (not (logtest? (-> obj bot-flags) (bot-flags attacked)))
+                     (>= (- (-> pp clock frame-counter) (-> obj attacker-time)) (seconds 1.5))
+                     )
+             (if (logtest? (-> obj bot-flags) (bot-flags attacked))
+                 (reset-attacker! obj)
+                 )
+             (set! s5-0 (the-as process #f))
+             (set! (-> obj attacker-handle) (the-as handle #f))
+             )
+           )
+          (else
+            (when (>= (- (-> pp clock frame-counter) (-> obj attacker-time)) (seconds 6))
+              (set! s5-0 (the-as process #f))
+              (set! (-> obj attacker-handle) (the-as handle #f))
+              )
+            )
+          )
+        )
+      (when s4-1
+        (when (or (>= (- (-> pp clock frame-counter) (-> obj arrest-attempt-time)) (seconds 0.5))
+                  (logtest? (-> (the-as process-focusable s4-1) focus-status) (focus-status dead hit))
+                  )
+          (set! s4-1 (the-as process #f))
+          (set! (-> obj arrestor-handle) (the-as handle #f))
+          )
+        )
+      (let ((v1-34 (-> obj focus-mode))
+            (s3-1 (the-as process #f))
+            )
+        (cond
+          ((zero? v1-34)
+           (cond
+             (s4-1
+               (set! s3-1 s4-1)
+               )
+             (s5-0
+               (set! s3-1 s5-0)
+               )
+             ((begin (set! s3-1 (select-focus! obj)) s3-1)
+              (empty)
+              )
+             (else
+               (let ((s5-1 (handle->process (-> obj poi-handle))))
+                 (set! s3-1 (if (type? s5-1 process-focusable)
+                                s5-1
+                                )
+                       )
+                 )
+               (if s3-1
+                   (empty)
+                   (set! s3-1 *target*)
+                   )
+               )
+             )
+           )
+          ((= v1-34 1)
+           (cond
+             (s4-1
+               (set! s3-1 s4-1)
+               )
+             (s5-0
+               (set! s3-1 s5-0)
+               )
+             (else
+               (let ((s5-2 (handle->process (-> obj poi-handle))))
+                 (set! s3-1 (if (type? s5-2 process-focusable)
+                                s5-2
+                                )
+                       )
+                 )
+               (cond
+                 (s3-1
+                   (empty)
+                   )
+                 ((begin (set! s3-1 (select-focus! obj)) s3-1)
+                  (empty)
+                  )
+                 (else
+                   (set! s3-1 *target*)
+                   )
+                 )
+               )
+             )
+           )
+          )
+        (cond
+          (s3-1
+            (try-update-focus (-> obj focus) (the-as process-focusable s3-1) obj)
+            (if (and (logtest? (-> obj bot-flags) (bot-flags attacked)) (!= (-> s3-1 type) target))
+                (logclear! (-> obj bot-flags) (bot-flags attacked))
+                )
+            )
+          (else
+            (clear-focused (-> obj focus))
+            (logclear! (-> obj bot-flags) (bot-flags attacked))
+            )
+          )
+        s3-1
+        )
+      )
+    )
+  )
+
+;; definition for method 183 of type kor
+(defmethod alive? kor ((obj kor))
+  (let ((t9-0 (method-of-type bot alive?)))
+    (and (t9-0 obj)
+         (not (and (-> obj next-state) (let ((v1-4 (-> obj next-state name)))
+                                         (or (= v1-4 'arrested) (= v1-4 'die) (= v1-4 'die-falling))
+                                         )
+                   )
+              )
+         (zero? (logand (bot-flags bf20) (-> obj bot-flags)))
+         )
+    )
+  )
+
+;; definition for method 114 of type kor
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-114 kor ((obj kor))
+  "@abstract"
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum hit-by-others))))
+    (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 3) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 4))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec bot bot-targetable))
+      (set! (-> s4-0 prim-core collide-with)
+            (collide-spec backgnd jak crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
+            )
+      (set! (-> s4-0 prim-core action) (collide-action solid can-ride no-standon))
+      (set-vector! (-> s4-0 local-sphere) 0.0 4505.6 0.0 7372.8)
+      (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 bot bot-targetable))
+      (set! (-> v1-13 prim-core collide-with)
+            (collide-spec backgnd jak crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-13 prim-core action) (collide-action solid can-ride))
+      (set-vector! (-> v1-13 local-sphere) 0.0 2867.2 0.0 2867.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 bot bot-targetable))
+      (set! (-> v1-15 prim-core collide-with)
+            (collide-spec backgnd jak crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-15 prim-core action) (collide-action solid))
+      (set-vector! (-> v1-15 local-sphere) 0.0 5529.6 0.0 2867.2)
+      )
+    (let ((v1-17 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-17 prim-core collide-as) (collide-spec bot bot-targetable))
+      (set! (-> v1-17 prim-core collide-with)
+            (collide-spec backgnd jak crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-17 prim-core action) (collide-action solid no-standon))
+      (set-vector! (-> v1-17 local-sphere) 0.0 8192.0 0.0 2867.2)
+      )
+    (set! (-> s5-0 nav-radius) 4096.0)
+    (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! (-> s5-0 max-iteration-count) (the-as uint 3))
+    (set! (-> s5-0 event-priority) (the-as uint 2))
+    (set! (-> obj root-override2) s5-0)
+    )
+  0
+  (none)
+  )
+
+;; definition for method 210 of type kor
+;; WARN: Return type mismatch int vs none.
+(defmethod init! kor ((obj kor))
+  "Set defaults for various fields."
+  (let ((t9-0 (method-of-type bot init!)))
+    (t9-0 obj)
+    )
+  (set! (-> obj min-speed) 6144.0)
+  (set! (-> obj max-speed) 20889.6)
+  (set! (-> obj channel) (the-as uint 27))
+  (set! (-> obj notice-enemy-dist) 122880.0)
+  (set! (-> obj travel-anim-interp) 0.0)
+  (set! (-> obj focus-info max-los-dist) 0.0)
+  (set-vector! (-> obj root-override2 scale) 1.2 1.2 1.2 1.0)
+  (set! (-> obj spot-color) (the-as uint #x508f2f00))
+  (set! (-> obj arrestor-handle) (the-as handle #f))
+  0
+  (none)
+  )
+
+;; definition for method 115 of type kor
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-115 kor ((obj kor))
+  "@abstract"
+  (init! obj)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-kor" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (enemy-method-113 obj *kor-nav-enemy-info*)
+  (let ((v1-7 (-> obj neck)))
+    (set! (-> v1-7 up) (the-as uint 1))
+    (set! (-> v1-7 nose) (the-as uint 2))
+    (set! (-> v1-7 ear) (the-as uint 0))
+    (set-vector! (-> v1-7 twist-max) 11832.889 11832.889 0.0 1.0)
+    (set! (-> v1-7 ignore-angle) 30947.555)
+    )
+  (let ((t9-4 (method-of-type bot enemy-method-115)))
+    (t9-4 obj)
+    )
+  (set! (-> obj my-simple-focus) (process-spawn simple-focus :to obj))
+  0
+  (none)
+  )
+
+;; definition for method 214 of type kor
+(defmethod bot-method-214 kor ((obj kor))
+  #f
+  )
+
+;; definition for method 70 of type kor
+(defmethod go-hostile kor ((obj kor))
+  (kor-method-232 obj)
+  (none)
+  )
+
+;; definition for method 72 of type kor
+(defmethod enemy-method-72 kor ((obj kor))
+  (kor-method-232 obj)
+  (none)
+  )
+
+;; definition for method 233 of type kor
+;; WARN: Return type mismatch object vs none.
+(defmethod kor-method-233 kor ((obj kor))
+  (go (method-of-object obj waiting-turn))
+  (none)
+  )
+
+;; definition for method 232 of type kor
+;; WARN: Return type mismatch object vs none.
+(defmethod kor-method-232 kor ((obj kor))
+  (let ((s5-0 (handle->process (-> obj arrestor-handle))))
+    (cond
+      ((if (type? s5-0 process-focusable)
+           s5-0
+           )
+       (go (method-of-object obj arrested))
+       )
+      ((logtest? (bot-flags bf19) (-> obj bot-flags))
+       (go (method-of-object obj scared-idle))
+       )
+      (else
+        (go (method-of-object obj waiting-idle))
+        )
+      )
+    )
+  (none)
+  )
+
+;; definition for method 234 of type kor
+;; WARN: Return type mismatch int vs none.
+(defmethod kor-method-234 kor ((obj kor))
+  (with-pp
+    (let ((f30-0 (-> obj nav state speed)))
+      (let ((f0-1 (lerp-scale 0.0 1.0 f30-0 6144.0 20889.6)))
+        (seek! (-> obj travel-anim-interp) f0-1 (* 4.0 (-> pp clock seconds-per-frame)))
+        )
+      (let ((f28-0 (-> obj travel-anim-interp))
+            (v1-7 (if (> (-> obj skel active-channels) 0)
+                      (-> obj skel root-channel 0 frame-group)
+                      )
+                  )
+            )
+        (cond
+          ((and v1-7 (= v1-7 (-> obj draw art-group data 5)))
+           (let ((v1-12 (-> obj skel root-channel 1)))
+             (set! (-> v1-12 frame-interp 1) f28-0)
+             (set! (-> v1-12 frame-interp 0) f28-0)
+             )
+           (let* ((f28-1 (current-cycle-distance (-> obj skel)))
+                  (f0-5 (quaternion-y-angle (-> obj root-override2 quat)))
+                  (f0-7 (deg- f0-5 (-> obj travel-prev-ry)))
+                  (f0-10 (fmin 20889.6 (* 0.35342914 (-> pp clock frames-per-second) (fabs f0-7))))
+                  (f0-13 (/ (* 24.0 (fmax f30-0 f0-10)) (* 15.0 f28-1)))
+                  (a0-10 (-> obj skel root-channel 0))
+                  )
+             (set! (-> a0-10 param 0) f0-13)
+             (joint-control-channel-group-eval! a0-10 (the-as art-joint-anim #f) num-func-loop!)
+             )
+           (let ((a0-11 (-> obj skel root-channel 1)))
+             (set! (-> a0-11 param 0) 0.0)
+             (joint-control-channel-group-eval! a0-11 (the-as art-joint-anim #f) num-func-chan)
+             )
+           )
+          (else
+            (ja-channel-push! 2 (seconds 0.3))
+            (let ((a0-13 (-> obj skel root-channel 0)))
+              (set! (-> a0-13 dist) 9830.4)
+              (set! (-> a0-13 frame-group) (the-as art-joint-anim (-> obj draw art-group data 5)))
+              (set! (-> a0-13 param 0) 1.0)
+              (joint-control-channel-group! a0-13 (the-as art-joint-anim (-> obj draw art-group data 5)) num-func-loop!)
+              )
+            (let ((a0-14 (-> obj skel root-channel 1)))
+              (set! (-> a0-14 frame-interp 1) f28-0)
+              (set! (-> a0-14 frame-interp 0) f28-0)
+              (set! (-> a0-14 dist) 19660.8)
+              (set! (-> a0-14 frame-group) (the-as art-joint-anim (-> obj draw art-group data 6)))
+              (set! (-> a0-14 param 0) 0.0)
+              (joint-control-channel-group! a0-14 (the-as art-joint-anim (-> obj draw art-group data 6)) num-func-chan)
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  )
+
+;; definition for method 56 of type kor
+(defmethod enemy-method-56 kor ((obj kor) (arg0 process) (arg1 event-message-block))
+  0
+  )
+
+;; definition for method 190 of type kor
+(defmethod bot-method-190 kor ((obj kor))
+  #t
+  )
+
+;; definition for method 78 of type kor
+(defmethod enemy-method-78 kor ((obj kor) (arg0 (pointer float)))
+  (ja-channel-push! 1 (seconds 0.1))
+  (let ((a1-2 (-> obj draw art-group data (-> obj enemy-info-override knocked-land-anim)))
+        (a0-4 (-> obj skel root-channel 0))
+        )
+    (set! (-> a0-4 frame-group) (the-as art-joint-anim a1-2))
+    (set! (-> a0-4 param 0) (the float (+ (-> (the-as art-joint-anim a1-2) 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-2) num-func-seek!)
+    )
+  #t
+  )
+
+;; definition for method 198 of type kor
+;; WARN: Return type mismatch float vs meters.
+(defmethod set-cam-height! kor ((obj kor) (arg0 vector))
+  (the-as
+    meters
+    (cond
+      ((and (-> obj next-state) (= (-> obj next-state name) 'arrested))
+       (set-vector! arg0 49152.0 12288.0 49152.0 1.0)
+       (vector<-cspace+vector! arg0 (-> obj node-list data 2) arg0)
+       (if (logtest? (-> obj focus-status) (focus-status under-water))
+           (set! (-> arg0 y) (+ (get-water-height obj) (-> *setting-control* cam-current target-height)))
+           )
+       )
+      (else
+        ((method-of-type bot set-cam-height!) obj arg0)
+        )
+      )
+    )
+  )
+
+;; definition for method 102 of type kor
+(defmethod enemy-method-102 kor ((obj kor))
+  (if (logtest? (bot-flags bf20) (-> obj bot-flags))
+      #f
+      ((method-of-type bot enemy-method-102) obj)
+      )
+  )
+
+;; definition for method 116 of type kor
+;; WARN: Return type mismatch object vs none.
+(defmethod go-idle kor ((obj kor))
+  (cond
+    ((= (-> obj course course-id) 8)
+     (cond
+       ((task-node-closed? (game-task-node city-help-kid-resolution))
+        (cleanup-for-death obj)
+        (go (method-of-object obj die-fast))
+        )
+       (else
+         (go (method-of-object obj waiting-with-kid))
+         )
+       )
+     )
+    (else
+      (go (method-of-object obj waiting-idle))
+      )
+    )
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/common/enemy/spyder_REF.gc b/test/decompiler/reference/jak2/levels/common/enemy/spyder_REF.gc
new file mode 100644
index 0000000000..4bed0682bf
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/common/enemy/spyder_REF.gc
@@ -0,0 +1,1445 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type spyder-shot
+(deftype spyder-shot (metalhead-shot)
+  ()
+  :heap-base #x170
+  :method-count-assert 40
+  :size-assert         #x1f0
+  :flag-assert         #x28017001f0
+  )
+
+;; definition for method 3 of type spyder-shot
+(defmethod inspect spyder-shot ((obj spyder-shot))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type metalhead-shot inspect)))
+    (t9-0 obj)
+    )
+  (label cfg-4)
+  obj
+  )
+
+;; definition for method 28 of type spyder-shot
+;; WARN: Return type mismatch int vs sound-id.
+(defmethod play-impact-sound spyder-shot ((obj spyder-shot) (arg0 projectile-options))
+  (let ((v1-0 arg0))
+    (cond
+      ((zero? v1-0)
+       (sound-play "spyder-fire")
+       )
+      ((= v1-0 (projectile-options lose-altitude))
+       (sound-play "spyder-shot-hit")
+       )
+      )
+    )
+  (the-as sound-id 0)
+  )
+
+;; definition for method 31 of type spyder-shot
+;; WARN: Return type mismatch int vs none.
+(defmethod init-proj-settings! spyder-shot ((obj spyder-shot))
+  "Init relevant settings for the [[projectile]] such as gravity, speed, timeout, etc
+:virtual"
+  ((the-as (function projectile none) (find-parent-method spyder-shot 31)) obj)
+  (set! (-> obj max-speed) 307200.0)
+  (set! (-> obj timeout) (seconds 0.267))
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-spyder spyder spyder-lod0-jg -1
+              ((spyder-lod0-mg (meters 20)) (spyder-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 5)
+              :shadow spyder-shadow-mg
+              :origin-joint-index 28
+              )
+
+;; definition of type spyder
+(deftype spyder (nav-enemy)
+  ((los               los-control  :inline   :offset-assert 608)
+   (joint             joint-mod              :offset-assert 756)
+   (start-pos         vector       :inline   :offset-assert 768)
+   (face-pos          vector       :inline   :offset        800)
+   (my-up-vector      vector       :inline   :offset-assert 816)
+   (status-flags      uint64                 :offset-assert 832)
+   (change-dir-timer  time-frame             :offset-assert 840)
+   (fire-info         vector       2 :inline :offset-assert 848)
+   (joint-ik          joint-mod-ik 4         :offset        880)
+   (delta-y-ik        float        4         :offset-assert 896)
+   (predator-effect?  symbol                 :offset-assert 912)
+   (shock-effect-time time-frame             :offset-assert 920)
+   (shock-effect-end  time-frame             :offset-assert 928)
+   (fade              float                  :offset-assert 936)
+   (dest-fade         float                  :offset-assert 940)
+   )
+  :heap-base #x330
+  :method-count-assert 186
+  :size-assert         #x3b0
+  :flag-assert         #xba033003b0
+  (:methods
+    (attack () _type_ :state 178)
+    (backup () _type_ :state 179)
+    (spyder-method-180 (_type_) none 180)
+    (spyder-method-181 (_type_) none 181)
+    (spyder-method-182 (_type_) none 182)
+    (spyder-method-183 (_type_ matrix float) none 183)
+    (spyder-method-184 (_type_ vector) none 184)
+    (spyder-method-185 (_type_) none 185)
+    )
+  )
+
+;; definition for method 3 of type spyder
+(defmethod inspect spyder ((obj spyder))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type nav-enemy inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tlos: #<los-control @ #x~X>~%" (-> obj los))
+  (format #t "~2Tjoint: ~A~%" (-> obj joint))
+  (format #t "~2Tstart-pos: #<vector @ #x~X>~%" (-> obj start-pos))
+  (format #t "~2Tfocus-pos: #<vector @ #x~X>~%" (-> obj focus-pos))
+  (format #t "~2Tface-pos: #<vector @ #x~X>~%" (-> obj face-pos))
+  (format #t "~2Tmy-up-vector: #<vector @ #x~X>~%" (-> obj my-up-vector))
+  (format #t "~2Tstatus-flags: ~D~%" (-> obj status-flags))
+  (format #t "~2Tchange-dir-timer: ~D~%" (-> obj change-dir-timer))
+  (format #t "~2Tfire-info[2] @ #x~X~%" (-> obj fire-info))
+  (format #t "~2Tjoint-ik[4] @ #x~X~%" (-> obj joint-ik))
+  (format #t "~2Tdelta-y-ik[4] @ #x~X~%" (-> obj delta-y-ik))
+  (format #t "~2Tpredator-effect?: ~A~%" (-> obj predator-effect?))
+  (format #t "~2Tshock-effect-time: ~D~%" (-> obj shock-effect-time))
+  (format #t "~2Tshock-effect-end: ~D~%" (-> obj shock-effect-end))
+  (format #t "~2Tfade: ~f~%" (-> obj fade))
+  (format #t "~2Tdest-fade: ~f~%" (-> obj dest-fade))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for symbol *spyder-nav-enemy-info*, type nav-enemy-info
+(define *spyder-nav-enemy-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #t
+    :use-victory #t
+    :use-jump-blocked #t
+    :debug-draw-neck #f
+    :jump-debug-draw #f
+    :move-to-ground #t
+    :hover-if-no-ground #f
+    :idle-anim-script (new 'static 'array idle-control-frame 4
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x4 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 4
+    :notice-anim 6
+    :hostile-anim 8
+    :hit-anim 15
+    :knocked-anim 16
+    :knocked-land-anim 20
+    :die-anim 12
+    :die-falling-anim 11
+    :victory-anim 7
+    :jump-wind-up-anim 21
+    :jump-in-air-anim 22
+    :jump-land-anim 23
+    :neck-joint 7
+    :look-at-joint 7
+    :bullseye-joint 28
+    :sound-hit (static-sound-name "spyder-hit")
+    :sound-die (static-sound-name "spyder-die")
+    :notice-distance (meters 80)
+    :notice-distance-delta (meters 10)
+    :proximity-notice-distance (meters 80)
+    :default-hit-points 8
+    :gnd-collide-with (collide-spec backgnd)
+    :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.8
+    :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 2730.6667
+    :knocked-soft-vxz-lo 90112.0
+    :knocked-soft-vxz-hi 131072.0
+    :knocked-soft-vy-lo 114688.0
+    :knocked-soft-vy-hi 155648.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 131072.0
+    :knocked-red-vy-lo 94208.0
+    :knocked-red-vy-hi 139264.0
+    :knocked-blue-vxz-lo 40960.0
+    :knocked-blue-vxz-hi 49152.0
+    :knocked-blue-vy-lo 57344.0
+    :knocked-blue-vy-hi 98304.0
+    :shadow-size (meters 2)
+    :shadow-max-y (meters 1)
+    :shadow-min-y (meters -1)
+    :shadow-locus-dist (meters 150)
+    :gem-joint 7
+    :gem-seg #x2
+    :gem-no-seg #x4
+    :gem-offset (new 'static 'sphere :y 819.2 :z 942.08 :r 163840.0)
+    :callback-info #f
+    :use-momentum #f
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #t
+    :use-pacing #t
+    :walk-anim 5
+    :turn-anim -1
+    :run-anim 8
+    :taunt-anim -1
+    :run-travel-speed (meters 8)
+    :run-acceleration (meters 1)
+    :run-turning-acceleration (meters 50)
+    :walk-travel-speed (meters 4)
+    :walk-acceleration (meters 1)
+    :walk-turning-acceleration (meters 3)
+    :maximum-rotation-rate (degrees 360.0)
+    :notice-nav-radius (meters 35)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :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! (-> *spyder-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+;; definition for method 74 of type spyder
+(defmethod enemy-method-74 spyder ((obj spyder) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (with-pp
+    (case arg2
+      (('hit-knocked)
+       (logclear! (-> obj mask) (process-mask actor-pause))
+       (logclear! (-> obj focus-status) (focus-status dangerous))
+       (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice))
+       (logior! (-> obj enemy-flags) (enemy-flag chase-startup))
+       (logior! (-> obj focus-status) (focus-status hit))
+       (if (zero? (-> obj hit-points))
+           (logior! (-> obj focus-status) (focus-status dead))
+           )
+       (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup))
+       (enemy-method-62 obj)
+       (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
+       (process-contact-action arg0)
+       (send-event arg0 'get-attack-count 1)
+       (when (zero? (-> obj hit-points))
+         (case (-> obj incoming knocked-type)
+           (((knocked-type knocked-type-4) (knocked-type knocked-type-6))
+            (set! (-> obj incoming knocked-type) (knocked-type knocked-type-0))
+            0
+            )
+           )
+         )
+       (go (method-of-object obj knocked))
+       )
+      (('attack)
+       (if (type? (-> arg0 parent 0) enemy)
+           (logior! (-> obj status-flags) 2)
+           )
+       ((method-of-type nav-enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+       )
+      (('notify)
+       (cond
+         ((= (-> arg3 param 0) 'attack)
+          (cond
+            ((= (-> arg3 param 1) (handle->process (-> obj focus handle)))
+             (let ((a1-6 (new 'stack-no-clear 'event-message-block)))
+               (set! (-> a1-6 from) (process->ppointer arg0))
+               (set! (-> a1-6 num-params) (the-as int arg1))
+               (set! (-> a1-6 message) 'victory)
+               (set! (-> a1-6 param 0) (-> arg3 param 0))
+               (set! (-> a1-6 param 1) (-> arg3 param 1))
+               (set! (-> a1-6 param 2) (-> arg3 param 2))
+               (set! (-> a1-6 param 3) (-> arg3 param 3))
+               (set! (-> a1-6 param 4) (-> arg3 param 4))
+               (set! (-> a1-6 param 5) (-> arg3 param 5))
+               (send-event-function obj a1-6)
+               )
+             )
+            (else
+              ((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)
+           )
+         )
+       )
+      (('uncloak)
+       (when (!= (-> obj dest-fade) 128.0)
+         (set! (-> obj shock-effect-end) (+ (-> pp clock frame-counter) (seconds 1)))
+         (set! (-> obj dest-fade) 128.0)
+         (sound-play "spyder-uncloak")
+         )
+       (send-event obj 'cue-chase)
+       ((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 180 of type spyder
+;; WARN: Return type mismatch int vs none.
+(defmethod spyder-method-180 spyder ((obj spyder))
+  (with-pp
+    (seek! (-> obj fade) (-> obj dest-fade) (* 500.0 (-> pp clock seconds-per-frame)))
+    (set! (-> obj draw force-fade) (the-as uint (the int (-> obj fade))))
+    (cond
+      ((zero? (-> obj draw force-fade))
+       (setup-masks (-> obj draw) 16 0)
+       (setup-masks (-> obj draw) 0 8)
+       (logclear! (-> obj draw status) (draw-control-status force-fade warp-cross-fade))
+       )
+      ((= (-> obj draw force-fade) 128)
+       (setup-masks (-> obj draw) 0 16)
+       (setup-masks (-> obj draw) 8 0)
+       (logclear! (-> obj draw status) (draw-control-status force-fade warp-cross-fade))
+       )
+      (else
+        (setup-masks (-> obj draw) 16 0)
+        (setup-masks (-> obj draw) 8 0)
+        (logior! (-> obj draw status) (draw-control-status force-fade warp-cross-fade))
+        )
+      )
+    (if (< 245760.0 (vector-vector-distance (-> obj root-override2 trans) (camera-pos)))
+        (setup-masks (-> obj draw) 0 16)
+        )
+    (when (< (-> pp clock frame-counter) (-> obj shock-effect-end))
+      (when (>= (- (-> pp clock frame-counter) (-> obj shock-effect-time)) (seconds 0.04))
+        (set! (-> obj shock-effect-time) (-> pp clock frame-counter))
+        (process-drawable-shock-skel-effect
+          obj
+          (-> *lightning-spec-id-table* 5)
+          lightning-probe-callback
+          (-> *part-id-table* 166)
+          2048.0
+          -1
+          -1
+          )
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+;; definition for method 181 of type spyder
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod spyder-method-181 spyder ((obj spyder))
+  (let ((a0-2 (handle->process (-> obj focus handle))))
+    (when a0-2
+      (let* ((s5-0 (-> obj root-override2 trans))
+             (s2-1 (vector-! (new 'stack-no-clear 'vector) (get-trans (the-as process-focusable a0-2) 0) s5-0))
+             (f0-0 (vector-length s2-1))
+             (s4-0 (new 'stack-no-clear 'vector))
+             )
+        (cond
+          ((>= 143360.0 f0-0)
+           (let ((s3-0 (new 'stack-no-clear 'vector)))
+             (logxor! (-> obj status-flags) 16)
+             (if (logtest? (-> obj status-flags) 16)
+                 (set-vector! s3-0 (-> s2-1 z) (-> s2-1 y) (- (-> s2-1 x)) 1.0)
+                 (set-vector! s3-0 (- (-> s2-1 z)) (-> s2-1 y) (-> s2-1 x) 1.0)
+                 )
+             (vector-normalize! s3-0 (* 4096.0 (rand-vu-float-range 8.0 16.0)))
+             (clamp-vector-to-mesh-cross-gaps
+               (-> obj nav)
+               s5-0
+               (-> obj nav state current-poly)
+               s3-0
+               204.8
+               #f
+               (the-as clamp-travel-vector-to-mesh-return-info #f)
+               )
+             (vector+! s4-0 s5-0 s3-0)
+             )
+           )
+          (else
+            (vector-normalize! s2-1 (+ -122880.0 f0-0))
+            (vector+! s4-0 s5-0 s2-1)
+            )
+          )
+        (set! (-> obj move-dest quad) (-> s5-0 quad))
+        (cloest-point-on-mesh (-> obj nav) (-> obj move-dest) s4-0 (the-as nav-poly #f))
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+;; definition for method 77 of type spyder
+;; WARN: Using new Jak 2 rtype-of
+(defmethod enemy-method-77 spyder ((obj spyder) (arg0 (pointer float)))
+  (case (-> obj incoming knocked-type)
+    (((knocked-type knocked-type-4))
+     (let ((a0-2 (-> obj skel root-channel 0)))
+       (set! (-> a0-2 frame-group) (the-as art-joint-anim (-> obj draw art-group data 15)))
+       (set! (-> a0-2 param 0)
+             (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 15)) frames num-frames) -1))
+             )
+       (set! (-> a0-2 param 1) (-> arg0 0))
+       (set! (-> a0-2 frame-num) 0.0)
+       (joint-control-channel-group! a0-2 (the-as art-joint-anim (-> obj draw art-group data 15)) num-func-seek!)
+       )
+     #t
+     )
+    (((knocked-type knocked-type-6))
+     (let* ((a0-4 '((spyder-blue-hit0-ja) (spyder-blue-hit1-ja) (spyder-blue-hit2-ja)))
+            (a1-4 ((method-of-type (rtype-of a0-4) length) a0-4))
+            (s5-0 (new 'static 'array uint64 3 #x11 #x12 #x13))
+            (s4-0 (new 'static 'array int32 4 0 0 0 0))
+            (a2-1 (ash 1 (-> s4-0 0)))
+            (v1-20 (enemy-method-120 obj a1-4 a2-1))
+            (s5-1 (-> obj draw art-group data (-> (the-as (pointer int32) (+ (* v1-20 8) (the-as int s5-0))))))
+            )
+       (set! (-> s4-0 0) v1-20)
+       (let ((v1-23 (if (> (-> obj skel active-channels) 0)
+                        (-> obj skel root-channel 0 frame-group)
+                        )
+                    )
+             )
+         (if (and v1-23 (= v1-23 (-> obj draw art-group data 20)))
+             (ja-channel-push! 1 (seconds 0.17))
+             (ja-channel-push! 1 (seconds 0.02))
+             )
+         )
+       (let ((a0-19 (-> obj skel root-channel 0)))
+         (set! (-> a0-19 frame-group) (the-as art-joint-anim s5-1))
+         (set! (-> a0-19 param 0) (the float (+ (-> (the-as art-joint-anim s5-1) frames num-frames) -1)))
+         (set! (-> a0-19 param 1) 1.0)
+         (set! (-> a0-19 frame-num) 0.0)
+         (joint-control-channel-group! a0-19 (the-as art-joint-anim s5-1) num-func-seek!)
+         )
+       )
+     #t
+     )
+    (((knocked-type knocked-type-0))
+     (cond
+       ((zero? (-> obj hit-points))
+        (let ((a0-20 (-> obj skel root-channel 0)))
+          (set! (-> a0-20 frame-group) (the-as art-joint-anim (-> obj draw art-group data 13)))
+          (set! (-> a0-20 param 0)
+                (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 13)) frames num-frames) -1))
+                )
+          (set! (-> a0-20 param 1) (-> arg0 0))
+          (set! (-> a0-20 frame-num) 0.0)
+          (joint-control-channel-group! a0-20 (the-as art-joint-anim (-> obj draw art-group data 13)) num-func-seek!)
+          )
+        #t
+        )
+       (else
+         ((method-of-type nav-enemy enemy-method-77) obj arg0)
+         )
+       )
+     )
+    (else
+      ((method-of-type nav-enemy enemy-method-77) obj arg0)
+      )
+    )
+  )
+
+;; definition for method 78 of type spyder
+(defmethod enemy-method-78 spyder ((obj spyder) (arg0 (pointer float)))
+  (case (-> obj incoming knocked-type)
+    (((knocked-type knocked-type-4))
+     (cond
+       ((zero? (-> obj hit-points))
+        (let ((v1-4 (-> obj skel root-channel 0)))
+          (set! (-> v1-4 frame-group) (the-as art-joint-anim (-> obj draw art-group data 12)))
+          (set! (-> v1-4 param 0)
+                (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 12)) frames num-frames) -1))
+                )
+          (set! (-> v1-4 param 1) 1.0)
+          (set! (-> v1-4 frame-num) 0.0)
+          (joint-control-channel-group! v1-4 (the-as art-joint-anim (-> obj draw art-group data 12)) num-func-seek!)
+          )
+        #t
+        )
+       (else
+         #f
+         )
+       )
+     )
+    (((knocked-type knocked-type-0))
+     (if (zero? (-> obj hit-points))
+         #t
+         ((method-of-type nav-enemy enemy-method-78) obj arg0)
+         )
+     )
+    (else
+      ((method-of-type nav-enemy enemy-method-78) obj arg0)
+      )
+    )
+  )
+
+;; definition for method 87 of type spyder
+(defmethod enemy-method-87 spyder ((obj spyder) (arg0 enemy-jump-info))
+  (let ((s5-0 (-> obj draw art-group data (-> obj enemy-info-override jump-in-air-anim))))
+    (let ((v1-6 (if (> (-> obj skel active-channels) 0)
+                    (-> obj skel root-channel 0 frame-group)
+                    )
+                )
+          )
+      (cond
+        ((and v1-6 (= v1-6 (-> obj draw art-group data (-> obj enemy-info-override jump-wind-up-anim))))
+         (ja-channel-push! 1 0)
+         )
+        (else
+          (let ((a0-10 (-> obj skel root-channel 0)))
+            (set! (-> a0-10 param 0) 1.0)
+            (joint-control-channel-group! a0-10 (the-as art-joint-anim #f) num-func-loop!)
+            )
+          (ja-channel-push! 1 (seconds 0.1))
+          )
+        )
+      )
+    (let ((a0-12 (-> obj skel root-channel 0)))
+      (set! (-> a0-12 frame-group) (the-as art-joint-anim s5-0))
+      (set! (-> a0-12 param 0) (the float (+ (-> (the-as art-joint-anim s5-0) frames num-frames) -1)))
+      (set! (-> a0-12 param 1) (-> arg0 anim-speed))
+      (set! (-> a0-12 frame-num) 0.0)
+      (joint-control-channel-group! a0-12 (the-as art-joint-anim s5-0) num-func-seek!)
+      )
+    )
+  #t
+  )
+
+;; definition for function spyder-travel-post
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defbehavior spyder-travel-post spyder ()
+  (set! (-> self face-pos quad) (-> self move-dest quad))
+  (logior! (-> self status-flags) 8)
+  (nav-enemy-travel-post)
+  0
+  (none)
+  )
+
+;; definition for function spyder-face-player-post
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defbehavior spyder-face-player-post spyder ()
+  (logior! (-> self status-flags) 8)
+  (let ((gp-0 (handle->process (-> self focus handle)))
+        (f30-0 (-> self nav max-rotation-rate))
+        )
+    (when gp-0
+      (set! (-> self face-pos quad) (-> (get-trans (the-as process-focusable gp-0) 0) quad))
+      (let ((a0-4 self))
+        (if (logtest? (enemy-flag enemy-flag37) (-> a0-4 enemy-flags))
+            (seek-to-point-toward-point!
+              (-> self root-override2)
+              (get-trans (the-as process-focusable gp-0) 0)
+              f30-0
+              (seconds 0.02)
+              )
+            )
+        )
+      )
+    )
+  (nav-enemy-simple-post)
+  0
+  (none)
+  )
+
+;; definition for method 182 of type spyder
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod spyder-method-182 spyder ((obj spyder))
+  (with-pp
+    (cond
+      ((and (logtest? (-> obj status-flags) 4) (!= (-> obj joint scale z) 1.0))
+       (seek! (-> obj joint scale z) 1.0 (* 0.8 (-> pp clock seconds-per-frame)))
+       )
+      ((and (not (logtest? (-> obj status-flags) 4)) (!= (-> obj joint scale z) 0.0))
+       (seek! (-> obj joint scale z) 0.0 (* 0.8 (-> pp clock seconds-per-frame)))
+       )
+      )
+    (let ((s5-0 (new 'stack-no-clear 'quaternion)))
+      (let ((a1-2 (-> obj node-list data 37 bone transform)))
+        (matrix-with-scale->quaternion s5-0 a1-2)
+        )
+      (let ((a1-4 (quaternion-from-two-vectors! (new 'stack-no-clear 'quaternion) (-> obj my-up-vector) *up-vector*)))
+        (quaternion*! s5-0 a1-4 s5-0)
+        )
+      (let ((s4-1 (vector-! (new 'stack-no-clear 'vector) (-> obj face-pos) (-> obj root-override2 trans)))
+            (s3-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
+            )
+        (cond
+          ((logtest? (-> obj status-flags) 8)
+           (vector-! s4-1 (-> obj face-pos) (-> obj root-override2 trans))
+           (set! (-> obj status-flags) (logand -9 (-> obj status-flags)))
+           )
+          (else
+            (set! (-> s4-1 quad) (-> s3-0 quad))
+            )
+          )
+        (set! (-> s4-1 y) 0.0)
+        (vector-xz-normalize! s4-1 1.0)
+        (set! (-> s3-0 y) 0.0)
+        (vector-xz-normalize! s3-0 1.0)
+        (let ((a1-11 (quaternion-from-two-vectors-max-angle! (new 'stack-no-clear 'quaternion) s3-0 s4-1 10012.444)))
+          (quaternion*! s5-0 a1-11 s5-0)
+          )
+        )
+      (quaternion-slerp!
+        (the-as quaternion (-> obj joint twist))
+        (the-as quaternion (-> obj joint twist))
+        s5-0
+        (* 10.0 (-> pp clock seconds-per-frame))
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+;; definition for method 184 of type spyder
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod spyder-method-184 spyder ((obj spyder) (arg0 vector))
+  (with-pp
+    (when (not (logtest? (-> obj status-flags) 1))
+      (let ((s4-0 (new 'stack-no-clear 'vector)))
+        (set! (-> s4-0 quad) (-> *up-vector* quad))
+        (let ((s3-0 (new 'stack-no-clear 'quaternion)))
+          (quaternion-from-two-vectors-max-angle! s3-0 s4-0 (-> obj root-override2 gspot-normal) 4551.1113)
+          (vector-orient-by-quat! s4-0 s4-0 s3-0)
+          )
+        (let ((s3-1 (-> obj my-up-vector)))
+          (vector-deg-seek s3-1 s3-1 s4-0 (* 16384.0 (-> pp clock seconds-per-frame)))
+          (vector-normalize! s3-1 1.0)
+          (forward-up-nopitch->quaternion (-> obj root-override2 quat) arg0 s3-1)
+          )
+        )
+      (logior! (-> obj status-flags) 1)
+      )
+    0
+    (none)
+    )
+  )
+
+;; definition for method 55 of type spyder
+(defmethod enemy-method-55 spyder ((obj spyder))
+  (spyder-method-185 obj)
+  (spyder-method-184 obj (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
+  (update-trans! (-> obj sound) (-> obj root-override2 trans))
+  (update! (-> obj sound))
+  (spyder-method-182 obj)
+  (let ((t9-6 (method-of-type nav-enemy enemy-method-55)))
+    (t9-6 obj)
+    )
+  (set! (-> obj status-flags) (logand -2 (-> obj status-flags)))
+  (if (logtest? (-> obj status-flags) 32)
+      (los-control-method-9 (-> obj los) (the-as process-focusable #f) (the-as vector #f) 2048.0)
+      )
+  (if (-> obj predator-effect?)
+      (spyder-method-180 obj)
+      )
+  (none)
+  )
+
+;; definition of type ik-setup
+(deftype ik-setup (structure)
+  ((elbow-index int32  :offset-assert   0)
+   (hand-dist   float  :offset-assert   4)
+   )
+  :method-count-assert 9
+  :size-assert         #x8
+  :flag-assert         #x900000008
+  )
+
+;; definition for method 3 of type ik-setup
+(defmethod inspect ik-setup ((obj ik-setup))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'ik-setup)
+  (format #t "~1Telbow-index: ~D~%" (-> obj elbow-index))
+  (format #t "~1Thand-dist: ~f~%" (-> obj hand-dist))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for symbol *spyder-ik-setup*, type (inline-array ik-setup)
+(define *spyder-ik-setup* (new 'static 'inline-array ik-setup 4
+                            (new 'static 'ik-setup :elbow-index 30 :hand-dist -7577.6)
+                            (new 'static 'ik-setup :elbow-index 32 :hand-dist 7577.6)
+                            (new 'static 'ik-setup :elbow-index 34 :hand-dist 7577.6)
+                            (new 'static 'ik-setup :elbow-index 36 :hand-dist -7577.6)
+                            )
+        )
+
+;; failed to figure out what this is:
+(defstate notice (spyder)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy notice) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (when (!= (-> self dest-fade) 128.0)
+      (set! (-> self shock-effect-end) (+ (-> self clock frame-counter) (seconds 1)))
+      (set! (-> self dest-fade) 128.0)
+      )
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate active (spyder)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy active) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (dotimes (gp-0 4)
+      (enable-set! (-> self joint-ik gp-0) #t)
+      )
+    (none)
+    )
+  )
+
+;; definition for method 185 of type spyder
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod spyder-method-185 spyder ((obj spyder))
+  (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 ((s5-0 (new 'stack-no-clear 'collide-query)))
+        (let ((v1-0 (-> s5-0 bbox))
+              (a0-2 (-> obj root-override2 trans))
+              (a1-0 (new 'stack-no-clear 'vector))
+              )
+          (set! (-> a1-0 x) 22528.0)
+          (set! (-> a1-0 y) 22528.0)
+          (set! (-> a1-0 z) 22528.0)
+          (set! (-> a1-0 w) 1.0)
+          (vector-! (the-as vector v1-0) a0-2 a1-0)
+          )
+        (let ((v1-2 (-> s5-0 bbox max))
+              (a0-4 (-> obj root-override2 trans))
+              (a1-1 (new 'stack-no-clear 'vector))
+              )
+          (set! (-> a1-1 x) 22528.0)
+          (set! (-> a1-1 y) 22528.0)
+          (set! (-> a1-1 z) 22528.0)
+          (set! (-> a1-1 w) 1.0)
+          (vector+! v1-2 a0-4 a1-1)
+          )
+        (set! (-> s5-0 collide-with) (collide-spec backgnd))
+        (set! (-> s5-0 ignore-process0) #f)
+        (set! (-> s5-0 ignore-process1) #f)
+        (set! (-> s5-0 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+        (fill-using-bounding-box *collide-cache* s5-0)
+        (dotimes (s4-0 4)
+          (-> obj joint-ik s4-0 shoulder-matrix-no-ik)
+          (let ((a2-8 (-> obj joint-ik s4-0 elbow-matrix-no-ik))
+                (s3-0 (new 'stack-no-clear 'vector))
+                )
+            (let ((v1-15 (new 'stack-no-clear 'vector)))
+              (set! (-> v1-15 quad) (-> *y-vector* quad))
+              (new 'stack-no-clear 'vector)
+              (let ((s2-0 (new 'stack-no-clear 'vector)))
+                (let ((a1-3 s3-0))
+                  (let ((a0-9 (-> a2-8 trans)))
+                    (let ((a2-9 (-> a2-8 vector 1)))
+                      (let ((a3-3 (-> obj joint-ik s4-0 hand-dist)))
+                        (.mov vf7 a3-3)
+                        )
+                      (.lvf vf5 (&-> a2-9 quad))
+                      )
+                    (.lvf vf4 (&-> a0-9 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! (-> s2-0 quad) (-> s3-0 quad))
+                (set! (-> s2-0 y) (-> obj root-override2 trans y))
+                (let ((a2-10 (-> s5-0 start-pos)))
+                  (let ((a0-12 s2-0))
+                    (let ((a1-6 v1-15))
+                      (let ((a3-5 16384.0))
+                        (.mov vf7 a3-5)
+                        )
+                      (.lvf vf5 (&-> a1-6 quad))
+                      )
+                    (.lvf vf4 (&-> a0-12 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 (&-> a2-10 quad) vf6)
+                  )
+                (vector-float*! (-> s5-0 move-dist) v1-15 -32768.0)
+                (let ((v1-16 s5-0))
+                  (set! (-> v1-16 radius) 40.96)
+                  (set! (-> v1-16 collide-with) (collide-spec backgnd))
+                  (set! (-> v1-16 ignore-process0) #f)
+                  (set! (-> v1-16 ignore-process1) #f)
+                  (set! (-> v1-16 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+                  (set! (-> v1-16 action-mask) (collide-action solid))
+                  )
+                (let ((f0-13 (probe-using-line-sphere *collide-cache* s5-0)))
+                  (when (>= f0-13 0.0)
+                    (let ((a1-10 s2-0))
+                      (let ((v1-19 (-> s5-0 start-pos)))
+                        (let ((a0-20 (-> s5-0 move-dist)))
+                          (let ((a2-11 f0-13))
+                            (.mov vf7 a2-11)
+                            )
+                          (.lvf vf5 (&-> a0-20 quad))
+                          )
+                        (.lvf vf4 (&-> v1-19 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-10 quad) vf6)
+                      )
+                    )
+                  )
+                (let ((f0-15 (fmax -8192.0 (fmin 8192.0 (- (-> s2-0 y) (-> s3-0 y))))))
+                  (+! (-> obj delta-y-ik s4-0) (* 10.0 (-> pp clock seconds-per-frame) (- f0-15 (-> obj delta-y-ik s4-0))))
+                  )
+                )
+              )
+            (+! (-> s3-0 y) (-> obj delta-y-ik s4-0))
+            (handle-copy! (-> obj joint-ik s4-0) s3-0)
+            )
+          )
+        )
+      0
+      (none)
+      )
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate hostile (spyder)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy hostile) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (spyder-method-181 self)
+    (enemy-method-109 self 2)
+    (set! (-> self status-flags) (logand -3 (-> self status-flags)))
+    (when (!= (-> self dest-fade) 128.0)
+      (set! (-> self shock-effect-end) (+ (-> self clock frame-counter) (seconds 1)))
+      (set! (-> self dest-fade) 128.0)
+      (sound-play "spyder-uncloak")
+      )
+    (none)
+    )
+  :exit (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy hostile) exit)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self status-flags) (logand -33 (-> self status-flags)))
+    (enemy-method-109 self 1)
+    (none)
+    )
+  :trans (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy hostile) trans)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (let ((a0-1 (handle->process (-> self focus handle))))
+      (when a0-1
+        (let ((gp-0 (new 'stack-no-clear 'vector)))
+          (set! (-> gp-0 quad) (-> (get-trans (the-as process-focusable a0-1) 0) quad))
+          (let* ((s5-0 (-> self root-override2 trans))
+                 (f30-0 (vector-vector-distance s5-0 gp-0))
+                 (f0-0 (vector-vector-xz-distance s5-0 (-> self move-dest)))
+                 )
+            (cond
+              ((>= (+ 2048.0 (-> self root-override2 nav-radius)) f0-0)
+               (if (and (>= 143360.0 f30-0) (check-los? (-> self los) 0))
+                   (go-virtual attack)
+                   )
+               (spyder-method-181 self)
+               )
+              ((>= 24576.0 f0-0)
+               (logior! (-> self status-flags) 32)
+               )
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :post (behavior ()
+    (let ((a0-0 (-> self nav state))
+          (v1-1 (-> self move-dest))
+          )
+      (logclear! (-> a0-0 flags) (nav-state-flag directional-mode))
+      (logior! (-> a0-0 flags) (nav-state-flag target-poly-dirty))
+      (set! (-> a0-0 target-post quad) (-> v1-1 quad))
+      )
+    0
+    (spyder-travel-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate backup (spyder)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior spyder) enemy-event-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (let ((v1-2 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-2 enemy-flags)))
+          (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-2 enemy-flags))))
+          )
+      (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-2 enemy-flags))))
+      (set! (-> v1-2 nav callback-info) (-> v1-2 enemy-info-override callback-info))
+      )
+    0
+    (none)
+    )
+  :trans (behavior ()
+    (let ((f0-0 (vector-vector-xz-distance (-> self root-override2 trans) (-> self move-dest))))
+      (if (or (>= 4096.0 f0-0) (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 6)))
+          (go-hostile self)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.1))
+    (until #f
+      (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override run-anim))
+                  :num! (seek!
+                    (the float
+                         (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override run-anim)))
+                                frames
+                                num-frames
+                                )
+                            -1
+                            )
+                         )
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (spyder-travel-post)
+    (none)
+    )
+  )
+
+;; definition for method 183 of type spyder
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch (pointer process) vs none.
+(defmethod spyder-method-183 spyder ((obj spyder) (arg0 matrix) (arg1 float))
+  (let ((gp-0 (new 'stack-no-clear 'projectile-init-by-other-params)))
+    (let ((v1-0 (-> arg0 vector))
+          (a1-1 (-> arg0 vector 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 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* ((a0-10 *game-info*)
+             (a3-11 (+ (-> a0-10 attack-id) 1))
+             )
+        (set! (-> a0-10 attack-id) a3-11)
+        (set! (-> gp-0 attack-id) a3-11)
+        )
+      (set! (-> gp-0 timeout) (new 'static 'handle :process #x4b0 :u64 #x4b0))
+      (vector-normalize! (vector-! (-> gp-0 vel) a1-1 (the-as vector v1-0)) arg1)
+      )
+    (spawn-projectile spyder-shot gp-0 obj *default-dead-pool*)
+    )
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate attack (spyder)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (let ((v1-0 event-type))
+      (the-as object (if (= v1-0 'event-attack)
+                         (the-as object (spyder-method-183 self (the-as matrix (-> self fire-info)) 307200.0))
+                         (enemy-event-handler proc arg1 event-type event)
+                         )
+              )
+      )
+    )
+  :enter (behavior ()
+    (let ((v1-1 (-> self nav state))
+          (a0-1 (-> self root-override2 trans))
+          )
+      (logclear! (-> v1-1 flags) (nav-state-flag directional-mode))
+      (logior! (-> v1-1 flags) (nav-state-flag target-poly-dirty))
+      (set! (-> v1-1 target-post quad) (-> a0-1 quad))
+      )
+    0
+    (let ((v1-4 self))
+      (set! (-> v1-4 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-4 enemy-flags))))
+      )
+    0
+    (enemy-method-109 self 1)
+    (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags)))
+    (none)
+    )
+  :exit (behavior ()
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (let ((v1-2 (-> self nav)))
+      (set! (-> v1-2 max-rotation-rate) (-> *spyder-nav-enemy-info* maximum-rotation-rate))
+      )
+    0
+    (none)
+    )
+  :trans (behavior ()
+    (if (and (logtest? (-> self enemy-flags) (enemy-flag look-at-focus)) (-> self enemy-info-override use-victory))
+        (go-virtual victory)
+        )
+    (if (or (>= 2 (the-as int (-> self focus aware))) (not (enemy-method-107 self)))
+        (go-stare self)
+        )
+    (none)
+    )
+  :code (behavior ()
+    (when (not (enemy-method-96 self 2730.6667 #t))
+      (ja-channel-push! 1 (seconds 0.2))
+      (ja :group! spyder-patrol0-ja)
+      (ja :num-func num-func-identity :frame-num 0.0)
+      (until (enemy-method-96 self 910.2222 #t)
+        (ja-blend-eval)
+        (suspend)
+        (ja :num! (loop! 0.75))
+        )
+      )
+    (let ((v1-17 (-> self nav)))
+      (set! (-> v1-17 max-rotation-rate) (* 0.05 (-> *spyder-nav-enemy-info* maximum-rotation-rate)))
+      )
+    0
+    (ja-channel-push! 2 (seconds 0.2))
+    (let ((f30-0 0.0))
+      (ja-no-eval :group! spyder-shoot-low-ja :num! (loop!) :frame-num 0.0)
+      (let ((a0-12 (-> self skel root-channel 1)))
+        (set! (-> a0-12 frame-interp 1) f30-0)
+        (set! (-> a0-12 frame-interp 0) f30-0)
+        (set! (-> a0-12 frame-group) (the-as art-joint-anim spyder-shoot-high-ja))
+        (set! (-> a0-12 param 0) 0.0)
+        (set! (-> a0-12 frame-num) 0.0)
+        (joint-control-channel-group! a0-12 (the-as art-joint-anim spyder-shoot-high-ja) num-func-chan)
+        )
+      (let ((a0-14 (handle->process (-> self focus handle))))
+        (when a0-14
+          (let ((gp-0 (new 'stack-no-clear 'vector)))
+            (set! (-> gp-0 quad) (-> (get-trans (the-as process-focusable a0-14) 0) quad))
+            (let ((s5-0 (new 'stack-no-clear 'vector)))
+              (set! (-> s5-0 quad) (-> gp-0 quad))
+              (let ((f28-0 0.0))
+                (dotimes (s4-0 8)
+                  (let* ((f26-0 (fmin (-> self root-override2 trans y) (-> gp-0 y)))
+                         (s3-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 27)))
+                         (f0-11 (fmin 40960.0 (+ -16384.0 (vector-vector-distance s3-0 gp-0))))
+                         (s2-1 (vector-! (new 'stack-no-clear 'vector) s3-0 gp-0))
+                         )
+                    (vector-normalize! s2-1 (- f0-11 f28-0))
+                    (vector+! s2-1 gp-0 s2-1)
+                    (set! (-> s2-1 y) f26-0)
+                    (set! (-> self fire-info 0 quad) (-> s3-0 quad))
+                    (set! (-> self fire-info 1 quad) (-> s2-1 quad))
+                    )
+                  (let ((s3-1 (-> self clock frame-counter)))
+                    (until (>= (- (-> self clock frame-counter) s3-1) (seconds 0.2))
+                      (set! f30-0 (seek f30-0 (lerp-scale 0.0 1.0 (the float s4-0) 0.0 8.0) (-> self clock seconds-per-frame)))
+                      (ja :num! (loop!))
+                      (let ((a0-27 (-> self skel root-channel 1)))
+                        (set! (-> a0-27 frame-interp 1) f30-0)
+                        (set! (-> a0-27 frame-interp 0) f30-0)
+                        (set! (-> a0-27 param 0) 0.0)
+                        (joint-control-channel-group-eval! a0-27 (the-as art-joint-anim #f) num-func-chan)
+                        )
+                      (suspend)
+                      )
+                    )
+                  (let ((f28-1 (+ 12288.0 f28-0)))
+                    (set! (-> gp-0 quad) (-> s5-0 quad))
+                    (let ((a0-31 (handle->process (-> self focus handle))))
+                      (if a0-31
+                          (set! (-> s5-0 quad) (-> (get-trans (the-as process-focusable a0-31) 0) quad))
+                          )
+                      )
+                    (set! f28-0 (fmax 0.0 (- f28-1 (vector-vector-distance gp-0 s5-0))))
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    (until (ja-done? 0)
+      (ja :num! (seek! 2.0))
+      (let ((a0-36 (-> self skel root-channel 1)))
+        (let ((f0-23 1.0))
+          (set! (-> a0-36 frame-interp 1) f0-23)
+          (set! (-> a0-36 frame-interp 0) f0-23)
+          )
+        (set! (-> a0-36 param 0) 0.0)
+        (joint-control-channel-group-eval! a0-36 (the-as art-joint-anim #f) num-func-chan)
+        )
+      (suspend)
+      )
+    (let ((v1-88 self))
+      (set! (-> v1-88 enemy-flags) (the-as enemy-flag (logclear (-> v1-88 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (go-hostile self)
+    (none)
+    )
+  :post (behavior ()
+    (spyder-face-player-post)
+    (none)
+    )
+  )
+
+;; definition for method 70 of type spyder
+;; WARN: Return type mismatch object vs none.
+(defmethod go-hostile spyder ((obj spyder))
+  (if (and (not (logtest? (-> obj status-flags) 2)) (-> obj next-state) (let ((v1-5 (-> obj next-state name)))
+                                                                          (or (= v1-5 'notice) (= v1-5 'knocked))
+                                                                          )
+           )
+      (go (method-of-object obj attack))
+      )
+  (go (method-of-object obj hostile))
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate knocked (spyder)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy knocked) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self status-flags) (logand -5 (-> self status-flags)))
+    (dotimes (gp-0 4)
+      (enable-set! (-> self joint-ik gp-0) #f)
+      )
+    (none)
+    )
+  :exit (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy knocked) exit)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (when (nonzero? (-> self hit-points))
+      (logior! (-> self status-flags) 4)
+      (dotimes (gp-0 4)
+        (enable-set! (-> self joint-ik gp-0) #t)
+        )
+      )
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate victory (spyder)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self draw bounds w) 30310.4)
+    (none)
+    )
+  :exit (behavior ()
+    (set! (-> self draw bounds w) 20480.0)
+    (none)
+    )
+  )
+
+;; definition for method 142 of type spyder
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod nav-enemy-method-142 spyder ((obj spyder) (arg0 nav-control))
+  (let ((t9-0 (method-of-object obj spyder-method-184))
+        (a2-0 (-> arg0 state))
+        (a1-1 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> a1-1 quad) (-> a2-0 heading quad))
+    (t9-0 obj a1-1)
+    )
+  0
+  (none)
+  )
+
+;; definition for method 60 of type spyder
+(defmethod coin-flip? spyder ((obj spyder))
+  "@returns The result of a 50/50 RNG roll"
+  #f
+  )
+
+;; definition for method 63 of type spyder
+;; WARN: Return type mismatch none vs symbol.
+(defmethod enemy-method-63 spyder ((obj spyder) (arg0 process-focusable) (arg1 symbol))
+  (let ((t9-0 (method-of-type nav-enemy enemy-method-63)))
+    (the-as symbol (if (t9-0 obj arg0 arg1)
+                       (set-dst-proc! (-> obj los) (-> obj focus handle))
+                       )
+            )
+    )
+  )
+
+;; definition for method 114 of type spyder
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-114 spyder ((obj spyder))
+  "@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 7) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 8))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec enemy))
+      (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 can-ride deadly no-standon))
+      (set! (-> s4-0 transform-index) 5)
+      (set-vector! (-> s4-0 local-sphere) 0.0 6144.0 0.0 14336.0)
+      (set! (-> s5-0 root-prim) s4-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 enemy))
+      (set! (-> v1-14 prim-core collide-with)
+            (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list)
+            )
+      (set! (-> v1-14 prim-core action) (collide-action solid can-ride deadly))
+      (set-vector! (-> v1-14 local-sphere) 0.0 4915.2 0.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 enemy))
+      (set! (-> v1-16 prim-core collide-with)
+            (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list)
+            )
+      (set! (-> v1-16 prim-core action) (collide-action solid deadly no-standon))
+      (set-vector! (-> v1-16 local-sphere) 0.0 9830.4 0.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 enemy))
+      (set! (-> v1-18 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-18 prim-core action) (collide-action semi-solid deadly))
+      (set! (-> v1-18 transform-index) 5)
+      (set-vector! (-> v1-18 local-sphere) 0.0 0.0 0.0 4915.2)
+      )
+    (let ((v1-20 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-20 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-20 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-20 prim-core action) (collide-action deadly))
+      (set! (-> v1-20 transform-index) 28)
+      (set-vector! (-> v1-20 local-sphere) 0.0 0.0 0.0 2252.8)
+      )
+    (let ((v1-22 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-22 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-22 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-22 prim-core action) (collide-action deadly))
+      (set! (-> v1-22 transform-index) 20)
+      (set-vector! (-> v1-22 local-sphere) 0.0 0.0 0.0 2048.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 enemy))
+      (set! (-> v1-24 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-24 prim-core action) (collide-action deadly))
+      (set! (-> v1-24 transform-index) 10)
+      (set-vector! (-> v1-24 local-sphere) 0.0 0.0 0.0 2048.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 enemy))
+      (set! (-> v1-26 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-26 prim-core action) (collide-action deadly))
+      (set! (-> v1-26 transform-index) 7)
+      (set-vector! (-> v1-26 local-sphere) 0.0 0.0 0.0 2048.0)
+      )
+    (set! (-> s5-0 nav-radius) 12288.0)
+    (let ((v1-28 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-28 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-28 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 spyder
+;; WARN: Return type mismatch process-focusable vs spyder.
+(defmethod relocate spyder ((obj spyder) (arg0 int))
+  (if (nonzero? (-> obj joint))
+      (&+! (-> obj joint) arg0)
+      )
+  (dotimes (v1-4 4)
+    (if (nonzero? (-> obj joint-ik v1-4))
+        (&+! (-> obj joint-ik v1-4) arg0)
+        )
+    )
+  (the-as
+    spyder
+    ((the-as (function process-focusable int process-focusable) (find-parent-method spyder 7)) obj arg0)
+    )
+  )
+
+;; definition for method 115 of type spyder
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-115 spyder ((obj spyder))
+  "@abstract"
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-spyder" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (enemy-method-113 obj *spyder-nav-enemy-info*)
+  (let ((v1-5 (-> obj neck)))
+    (set! (-> v1-5 up) (the-as uint 1))
+    (set! (-> v1-5 nose) (the-as uint 2))
+    (set! (-> v1-5 ear) (the-as uint 0))
+    (set-vector! (-> v1-5 twist-max) 11832.889 11832.889 0.0 1.0)
+    (set! (-> v1-5 ignore-angle) 30947.555)
+    )
+  (let ((v1-7 (-> obj nav)))
+    (set! (-> v1-7 speed-scale) 1.0)
+    )
+  0
+  (set-gravity-length (-> obj root-override2 dynam) 573440.0)
+  (set-vector! (-> obj root-override2 scale) 1.5 1.5 1.5 1.0)
+  (set! (-> obj my-up-vector quad) (-> *up-vector* quad))
+  (set! (-> obj status-flags) (the-as uint 4))
+  (if (rand-vu-percent? 0.5)
+      (logior! (-> obj status-flags) 16)
+      )
+  (set! (-> obj start-pos quad) (-> obj root-override2 trans quad))
+  (set! (-> obj sound)
+        (new 'process 'ambient-sound (static-sound-spec "spyder-talk" :fo-max 70) (-> obj root-override2 trans))
+        )
+  (new-source! (-> obj los) obj (seconds 0.2) (collide-spec backgnd obstacle))
+  (set! (-> obj joint) (the-as joint-mod (new 'process 'joint-mod-blend-world obj 4 #t 1.0)))
+  (set! (-> obj joint scale x) (the-as float (logior (the-as int (-> obj joint scale x)) 4)))
+  (let ((f30-0 (-> obj root-override2 trans y)))
+    (dotimes (s5-1 4)
+      (set! (-> obj joint-ik s5-1)
+            (new 'process 'joint-mod-ik obj (-> *spyder-ik-setup* s5-1 elbow-index) (-> *spyder-ik-setup* s5-1 hand-dist))
+            )
+      (enable-set! (-> obj joint-ik s5-1) #f)
+      (set! (-> obj delta-y-ik 0) f30-0)
+      )
+    )
+  (cond
+    ((>= (res-lump-value (-> obj entity) 'extra-id int :default (the-as uint128 -1) :time -1000000000.0) 0)
+     (setup-masks (-> obj draw) 16 0)
+     (setup-masks (-> obj draw) 8 0)
+     (logior! (-> obj draw status) (draw-control-status force-fade warp-cross-fade))
+     (set! (-> obj draw force-fade) (the-as uint 0))
+     (set! (-> obj fade) 0.0)
+     (set! (-> obj dest-fade) 0.0)
+     (set! (-> obj predator-effect?) #t)
+     )
+    (else
+      (setup-masks (-> obj draw) 0 16)
+      (setup-masks (-> obj draw) 8 0)
+      (set! (-> obj predator-effect?) #f)
+      )
+    )
+  (add-connection *part-engine* obj 7 obj 318 (new 'static 'vector :x 901.12 :y -983.04 :z 942.08 :w 163840.0))
+  (add-connection *part-engine* obj 7 obj 318 (new 'static 'vector :x -901.12 :y -983.04 :z 942.08 :w 163840.0))
+  0
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/common/entities/spydroid_REF.gc b/test/decompiler/reference/jak2/levels/common/entities/spydroid_REF.gc
new file mode 100644
index 0000000000..fbcf8f6f89
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/common/entities/spydroid_REF.gc
@@ -0,0 +1,1543 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; failed to figure out what this is:
+(defpartgroup group-spydroid-trail
+  :id 709
+  :bounds (static-bspherem 0 0 0 8)
+  :parts ((sp-item 3162 :fade-after (meters 120) :falloff-to (meters 160))
+    (sp-item 3163 :flags (bit6))
+    (sp-item 3164 :fade-after (meters 120) :falloff-to (meters 160))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3163
+  :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.5))
+    (sp-rnd-flt spt-scale-x (meters 1.7) (meters 1) 1.0)
+    (sp-flt spt-rot-x 2048.0)
+    (sp-rnd-flt spt-rot-z (degrees -17.0) (degrees 17.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 0.0)
+    (sp-rnd-flt spt-g 192.0 64.0 1.0)
+    (sp-flt spt-b 255.0)
+    (sp-flt spt-a 16.0)
+    (sp-flt spt-omega 1230848.0)
+    (sp-flt spt-fade-a -1.0666667)
+    (sp-int spt-timer 10)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 3072.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3164
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x92 :page #xc))
+    (sp-rnd-flt spt-num 2.0 2.0 1.0)
+    (sp-flt spt-scale-x (meters 2.5))
+    (sp-int spt-rot-x 4)
+    (sp-flt spt-scale-y (meters 0.033))
+    (sp-flt spt-r 128.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-omega 6.144)
+    (sp-rnd-flt spt-vel-y (meters 0.06666667) (meters 0.06666667) 1.0)
+    (sp-flt spt-fade-r -8.0)
+    (sp-rnd-flt spt-fade-g -0.85 -0.85 1.0)
+    (sp-rnd-flt spt-fade-a -0.10666667 -0.42666668 1.0)
+    (sp-rnd-flt spt-accel-y -6.826667 -2.7306666 1.0)
+    (sp-flt spt-friction 0.96)
+    (sp-int-plain-rnd spt-timer 300 299 1)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-3)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-rnd-flt spt-conerot-x (degrees 135.0) (degrees 90.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-flt spt-conerot-radius (meters -0.5))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3162
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.5 1.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1.2) (meters 0.8) 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 0.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 64.0 8.0 1.0)
+    (sp-rnd-flt spt-vel-x (meters -0.0033333334) (meters 0.006666667) 1.0)
+    (sp-rnd-flt spt-vel-y (meters -0.006666667) (meters -0.006666667) 1.0)
+    (sp-rnd-flt spt-vel-z (meters -0.0033333334) (meters 0.006666667) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.006666667) (meters 0.008333334) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.3) (degrees 0.6) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 3.2)
+    (sp-flt spt-fade-g 0.0)
+    (sp-flt spt-fade-b -3.2)
+    (sp-flt spt-fade-a -0.8)
+    (sp-rnd-flt spt-accel-y 0.4096 0.13653333 1.0)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 600)
+    (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 40)
+    (sp-launcher-by-id spt-next-launcher 3165)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3165
+  :init-specs ((sp-flt spt-r 128.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (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.10666667 -0.21333334 1.0)
+    (sp-func spt-func 'nothing)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpartgroup group-spydroid-explode
+  :id 710
+  :duration (seconds 3)
+  :linger-duration (seconds 1)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 15)
+  :parts ((sp-item 3166 :flags (bit6) :period 900 :length 5)
+    (sp-item 3167 :flags (bit6) :period 900 :length 5)
+    (sp-item 3168 :period 900 :length 15)
+    (sp-item 3169 :fade-after (meters 60) :period 900 :length 10 :offset 10)
+    (sp-item 3170 :fade-after (meters 60) :falloff-to (meters 60) :period 900 :length 50 :offset 20)
+    (sp-item 3171 :fade-after (meters 200) :falloff-to (meters 200) :period 900 :length 25 :offset 20)
+    (sp-item 3172 :fade-after (meters 150) :falloff-to (meters 150) :period 900 :length 20 :offset 30)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3167
+  :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 2))
+    (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.10666667))
+    (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 -8.5)
+    (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 3173)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3173
+  :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 3172
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x34 :page #xc))
+    (sp-rnd-flt spt-num 2.0 0.2 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 655360.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.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-int spt-next-time 25)
+    (sp-launcher-by-id spt-next-launcher 3174)
+    (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 3171
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x33 :page #xc))
+    (sp-rnd-flt spt-num 1.0 0.2 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-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-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 spt-next-time 25)
+    (sp-launcher-by-id spt-next-launcher 3174)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3174
+  :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 3175)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3175
+  :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 3176)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3176
+  :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 3177)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3177
+  :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 3166
+  :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 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 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 3178)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3178
+  :init-specs ((sp-flt spt-scalevel-x (meters -0.2857143))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -3.6571429)
+    (sp-flt spt-fade-b 0.0)
+    (sp-flt spt-fade-a -2.7428572)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3170
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x32 :page #xc))
+    (sp-rnd-flt spt-num 8.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 -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 3179)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3179
+  :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 3180)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3180
+  :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 3168
+  :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 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 3181)
+    (sp-rnd-flt spt-conerot-x (degrees -1440.0) (degrees 2880.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3181
+  :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 3182)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3182
+  :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 3169
+  :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 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 90)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3183
+  :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 0.75))
+    (sp-flt spt-rot-x 204.8)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 0.0)
+    (sp-flt spt-b 0.0)
+    (sp-flt spt-a 16.0)
+    (sp-flt spt-omega 247808.0)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 409.6)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3184
+  :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 0.5))
+    (sp-flt spt-rot-x 204.8)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 0.0)
+    (sp-rnd-flt spt-g 128.0 64.0 1.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 16.0 4.0 1.0)
+    (sp-flt spt-omega 247808.0)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 409.6)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3185
+  :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 2) (meters 0.2) 1.0)
+    (sp-flt spt-rot-x 204.8)
+    (sp-rnd-flt spt-rot-z (degrees -2.0) (degrees 4.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 0.0)
+    (sp-rnd-flt spt-g 128.0 64.0 1.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 6.0 2.0 1.0)
+    (sp-flt spt-omega 329728.0)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 409.6)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3186
+  :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.75) (meters 0.1) 1.0)
+    (sp-flt spt-rot-x 204.8)
+    (sp-rnd-flt spt-rot-z (degrees -2.0) (degrees 4.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 64.0)
+    (sp-rnd-flt spt-g 128.0 64.0 1.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 32.0 4.0 1.0)
+    (sp-flt spt-omega 329728.0)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 409.6)
+    )
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-spydroid spydroid spydroid-lod0-jg spydroid-idle-ja
+              ((spydroid-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              :shadow spydroid-shadow-mg
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-spydroid-exploding spydroid spydroid-exploding-lod0-jg spydroid-exploding-idle-ja
+              ((spydroid-exploding-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 12)
+              )
+
+;; definition for symbol *spydroid-exploder-params*, type joint-exploder-static-params
+(define *spydroid-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 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 17 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 18 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 19 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 21 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 22 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 25 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 26 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 27 :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 23 :parent-joint-index -1)
+      )
+    :collide-spec #x241
+    )
+  )
+
+;; definition of type spydroid
+(deftype spydroid (nav-enemy)
+  ((old-y-deg    float                      :offset-assert 604)
+   (diff-angle   float                      :offset-assert 608)
+   (desire-turn  symbol                     :offset-assert 612)
+   (hit-target   basic                      :offset-assert 616)
+   (lightning    lightning-control        4 :offset-assert 620)
+   (floor        float                      :offset-assert 636)
+   (explode-part sparticle-launch-control   :offset-assert 640)
+   )
+  :heap-base #x210
+  :method-count-assert 179
+  :size-assert         #x284
+  :flag-assert         #xb302100284
+  (:methods
+    (attack () _type_ :state 178)
+    )
+  )
+
+;; definition for method 3 of type spydroid
+(defmethod inspect spydroid ((obj spydroid))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type nav-enemy inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Told-y-deg: ~f~%" (-> obj old-y-deg))
+  (format #t "~2Tdiff-angle: ~f~%" (-> obj diff-angle))
+  (format #t "~2Tdesire-turn: ~A~%" (-> obj desire-turn))
+  (format #t "~2Thit-target: ~A~%" (-> obj hit-target))
+  (format #t "~2Tlightning[4] @ #x~X~%" (-> obj lightning))
+  (format #t "~2Tfloor: ~f~%" (-> obj floor))
+  (format #t "~2Texplode-part: ~A~%" (-> obj explode-part))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for symbol *spydroid-nav-enemy-info*, type nav-enemy-info
+(define *spydroid-nav-enemy-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 #f
+    :hover-if-no-ground #f
+    :idle-anim-script (new 'static 'array idle-control-frame 4
+      (new 'static 'idle-control-frame :command (ic-cmd push) :param0 #x1e)
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x3 :param0 #x64 :param1 #x64)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 3
+    :notice-anim 3
+    :hostile-anim 5
+    :hit-anim 15
+    :knocked-anim 11
+    :knocked-land-anim 12
+    :die-anim 15
+    :die-falling-anim 15
+    :victory-anim -1
+    :jump-wind-up-anim 8
+    :jump-in-air-anim 9
+    :jump-land-anim 10
+    :neck-joint 4
+    :look-at-joint 4
+    :bullseye-joint 4
+    :sound-hit (static-sound-name "spydroid-hit")
+    :sound-die (static-sound-name "spydroid-die")
+    :notice-distance (meters 200)
+    :notice-distance-delta (meters 10)
+    :proximity-notice-distance (meters 20)
+    :default-hit-points 1
+    :gnd-collide-with (collide-spec backgnd obstacle hit-by-others-list)
+    :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+    :movement-gravity (meters -100)
+    :friction 0.8
+    :attack-shove-back (meters 3.5)
+    :attack-shove-up (meters 2)
+    :attack-mode 'shock
+    :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 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)
+    :callback-info #f
+    :use-momentum #t
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #t
+    :use-pacing #t
+    :walk-anim 4
+    :turn-anim -1
+    :run-anim 5
+    :taunt-anim -1
+    :run-travel-speed (meters 8)
+    :run-acceleration (meters 32)
+    :run-turning-acceleration (meters 40)
+    :walk-travel-speed (meters 4)
+    :walk-acceleration (meters 16)
+    :walk-turning-acceleration (meters 40)
+    :maximum-rotation-rate (degrees 360.0)
+    :notice-nav-radius (meters 2)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :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! (-> *spydroid-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+;; definition for method 55 of type spydroid
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-55 spydroid ((obj spydroid))
+  (let ((t9-0 (method-of-type nav-enemy enemy-method-55)))
+    (t9-0 obj)
+    )
+  (when (< (-> obj root-override2 scale x) 1.0)
+    (let ((f0-2 (fmin 1.0 (+ 0.025 (-> obj root-override2 scale x)))))
+      (set-vector! (-> obj root-override2 scale) f0-2 f0-2 f0-2 1.0)
+      )
+    )
+  (let ((s5-0 (new 'stack-no-clear 'vector))
+        (s4-0 (new 'stack-no-clear 'vector))
+        )
+    (vector<-cspace! s5-0 (-> obj node-list data 12))
+    (dotimes (s3-0 4)
+      (let ((a0-4 (-> obj lightning s3-0))
+            (v1-12 s5-0)
+            )
+        (set! (-> a0-4 state meet data 0 quad) (-> v1-12 quad))
+        )
+      (let ((v1-14 s3-0))
+        (cond
+          ((zero? v1-14)
+           (vector<-cspace! s4-0 (-> obj node-list data 16))
+           )
+          ((= v1-14 1)
+           (vector<-cspace! s4-0 (-> obj node-list data 20))
+           )
+          ((= v1-14 2)
+           (vector<-cspace! s4-0 (-> obj node-list data 28))
+           )
+          (else
+            (vector<-cspace! s4-0 (-> obj node-list data 24))
+            )
+          )
+        )
+      (let ((a0-13 (-> obj lightning s3-0))
+            (v1-25 s4-0)
+            )
+        (set! (-> a0-13 state meet data (+ (-> a0-13 state points-to-draw) -1) quad) (-> v1-25 quad))
+        )
+      (when (not (and (-> obj next-state) (= (-> obj next-state name) 'die-falling)))
+        (case (-> obj lightning s3-0 state mode)
+          (((lightning-mode lm0) (lightning-mode lm3))
+           (let ((v1-39 (-> obj lightning s3-0))
+                 (a0-19 1)
+                 )
+             (let ((a1-10 (!= a0-19 (-> v1-39 state mode))))
+               (case a0-19
+                 ((3)
+                  (if a1-10
+                      (set! (-> v1-39 state counter) 0.0)
+                      )
+                  )
+                 ((1)
+                  (set! (-> v1-39 state start-color) (-> v1-39 spec start-color))
+                  (set! (-> v1-39 state end-color) (-> v1-39 spec end-color))
+                  )
+                 )
+               )
+             (set! (-> v1-39 state mode) (the-as lightning-mode a0-19))
+             )
+           )
+          )
+        )
+      )
+    )
+  (let ((f0-5 (quaternion-y-angle (-> obj root-override2 quat))))
+    (set! (-> obj diff-angle) (- (-> obj old-y-deg) f0-5))
+    (cond
+      ((< 32768.0 (-> obj diff-angle))
+       (set! (-> obj diff-angle) (+ -65536.0 (-> obj diff-angle)))
+       )
+      ((< (-> obj diff-angle) -32768.0)
+       (set! (-> obj diff-angle) (+ 65536.0 (-> obj diff-angle)))
+       )
+      )
+    (set! (-> obj old-y-deg) f0-5)
+    )
+  (set! (-> obj desire-turn)
+        (< (+ 0.5 (* 0.00024414062 (-> obj nav state speed))) (* 0.005493164 (fabs (-> obj diff-angle))))
+        )
+  (if (and (< (-> obj root-override2 trans y) (+ -122880.0 (-> obj floor)))
+           (-> obj next-state)
+           (= (-> obj next-state name) 'jump)
+           )
+      (deactivate obj)
+      )
+  (if (and (-> obj next-state) (= (-> obj next-state name) 'jump))
+      (spawn (-> obj part) (-> obj root-override2 trans))
+      )
+  0
+  (none)
+  )
+
+;; definition for method 74 of type spydroid
+;; INFO: Used lq/sq
+(defmethod enemy-method-74 spydroid ((obj spydroid) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (local-vars (v1-6 vector) (sv-144 vector))
+  (with-pp
+    (rlet ((vf0 :class vf)
+           (vf4 :class vf)
+           (vf5 :class vf)
+           (vf6 :class vf)
+           )
+      (init-vf0-vector)
+      (case arg2
+        (('touch 'bonk 'attack)
+         (set! sv-144 (the-as vector (send-event (ppointer->process (-> obj parent)) 'widow-get-center)))
+         (let* ((s1-0 arg0)
+                (s0-0 (if (type? s1-0 process-drawable)
+                          s1-0
+                          )
+                      )
+                )
+           (let ((v1-5 sv-144))
+             (b! (not v1-5) cfg-15 :likely-delay (set! v1-6 sv-144))
+             )
+           (set! v1-6 (the-as vector s0-0))
+           (label cfg-15)
+           (cond
+             (v1-6
+               (let ((v1-9 (vector-! (new 'stack-no-clear 'vector) (-> obj root-override2 trans) sv-144))
+                     (s1-1 (new 'stack-no-clear 'vector))
+                     )
+                 (set! (-> s1-1 x) (- (-> v1-9 z)))
+                 (set! (-> s1-1 y) 0.0)
+                 (set! (-> s1-1 z) (-> v1-9 x))
+                 (set! (-> s1-1 w) 1.0)
+                 (let ((v1-12 (vector-!
+                                (new 'stack-no-clear 'vector)
+                                (-> (the-as process-drawable s0-0) root trans)
+                                (-> obj root-override2 trans)
+                                )
+                              )
+                       )
+                   (set! (-> s1-1 y) 0.0)
+                   (set! (-> v1-12 y) 0.0)
+                   (if (< (vector-dot v1-12 s1-1) 0.0)
+                       (vector-negate! s1-1 s1-1)
+                       )
+                   )
+                 (vector-normalize! s1-1 16384.0)
+                 (vector+! s1-1 s1-1 (-> (the-as process-drawable s0-0) root trans))
+                 (vector-! s1-1 s1-1 sv-144)
+                 (set! (-> s1-1 y) 0.0)
+                 (vector-normalize! s1-1 204800.0)
+                 (let ((v1-17 s1-1))
+                   (let ((a0-19 s1-1))
+                     (.mov.vf vf6 vf0 :mask #b1000)
+                     (.lvf vf4 (&-> a0-19 quad))
+                     )
+                   (.lvf vf5 (&-> (the-as vector sv-144) quad))
+                   (.add.vf vf6 vf4 vf5 :mask #b111)
+                   (.svf (&-> v1-17 quad) vf6)
+                   )
+                 (vector-! s1-1 s1-1 (-> (the-as process-drawable s0-0) root trans))
+                 (set! (-> s1-1 y) 8192.0)
+                 (let ((a1-17 (new 'stack-no-clear 'event-message-block)))
+                   (set! (-> a1-17 from) (process->ppointer pp))
+                   (set! (-> a1-17 num-params) 2)
+                   (set! (-> a1-17 message) 'attack)
+                   (set! (-> a1-17 param 0) (the-as uint #f))
+                   (let ((v1-23 (new 'static 'attack-info :mask (attack-info-mask vector mode id))))
+                     (let* ((a0-24 *game-info*)
+                            (a2-2 (+ (-> a0-24 attack-id) 1))
+                            )
+                       (set! (-> a0-24 attack-id) a2-2)
+                       (set! (-> v1-23 id) a2-2)
+                       )
+                     (set! (-> v1-23 mode) 'shock)
+                     (set! (-> v1-23 vector quad) (-> s1-1 quad))
+                     (set! (-> a1-17 param 1) (the-as uint v1-23))
+                     )
+                   (send-event-function arg0 a1-17)
+                   )
+                 )
+               )
+             (else
+               (let ((a1-18 (new 'stack-no-clear 'event-message-block)))
+                 (set! (-> a1-18 from) (process->ppointer pp))
+                 (set! (-> a1-18 num-params) 2)
+                 (set! (-> a1-18 message) 'attack)
+                 (set! (-> a1-18 param 0) (the-as uint #f))
+                 (let ((v1-28 (new 'static 'attack-info :mask (attack-info-mask mode shove-back shove-up id))))
+                   (let* ((a0-29 *game-info*)
+                          (a2-4 (+ (-> a0-29 attack-id) 1))
+                          )
+                     (set! (-> a0-29 attack-id) a2-4)
+                     (set! (-> v1-28 id) a2-4)
+                     )
+                   (set! (-> v1-28 mode) 'shock)
+                   (set! (-> v1-28 shove-up) 8192.0)
+                   (set! (-> v1-28 shove-back) 16384.0)
+                   (set! (-> a1-18 param 1) (the-as uint v1-28))
+                   )
+                 (send-event-function arg0 a1-18)
+                 )
+               )
+             )
+           )
+         (let ((v1-30 (the-as object (-> arg3 param 1))))
+           (if (or (!= arg0 *target*)
+                   (and (= arg2 'attack)
+                        (logtest? (attack-info-mask penetrate-using) (-> (the-as attack-info v1-30) mask))
+                        (logtest? (penetrate dark-bomb) (-> (the-as attack-info v1-30) penetrate-using))
+                        )
+                   )
+               ((method-of-type nav-enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+               )
+           )
+         )
+        (('jump)
+         (set! (-> obj floor) (-> (the-as vector (-> arg3 param 1)) y))
+         ((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)
+          )
+        )
+      )
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate die-falling (spydroid)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy die-falling) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :trans (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy die-falling) trans)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (if (< (- (-> self clock frame-counter) (-> self state-time)) (seconds 2))
+        (spawn (-> self explode-part) (-> self root-override2 trans))
+        )
+    (none)
+    )
+  :code (behavior ()
+    (dotimes (v1-0 4)
+      (let ((a0-2 (-> self lightning v1-0))
+            (a1-0 3)
+            )
+        (let ((a2-1 (!= a1-0 (-> a0-2 state mode))))
+          (case a1-0
+            ((3)
+             (if a2-1
+                 (set! (-> a0-2 state counter) 0.0)
+                 )
+             )
+            ((1)
+             (set! (-> a0-2 state start-color) (-> a0-2 spec start-color))
+             (set! (-> a0-2 state end-color) (-> a0-2 spec end-color))
+             )
+            )
+          )
+        (set! (-> a0-2 state mode) (the-as lightning-mode a1-0))
+        )
+      )
+    ((lambda :behavior spydroid
+       ()
+       (let ((gp-0 (new 'stack 'joint-exploder-tuning (the-as uint 0))))
+         (process-spawn
+           joint-exploder
+           (art-group-get-by-name *level* "skel-spydroid-exploding" (the-as (pointer uint32) #f))
+           20
+           gp-0
+           *spydroid-exploder-params*
+           :to self
+           )
+         )
+       )
+     )
+    (suspend)
+    (ja-channel-set! 0)
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 1))
+        (suspend)
+        )
+      )
+    (send-event self 'death-end)
+    (while (-> self child)
+      (suspend)
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate attack (spydroid)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior spydroid) enemy-event-handler)
+  :enter (behavior ()
+    (set! (-> self hit-target) #f)
+    (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags)))
+    (let ((v1-2 (-> self nav)))
+      (set! (-> v1-2 target-speed) (+ 8192.0 (-> self enemy-info-override run-travel-speed)))
+      )
+    0
+    (let ((v1-5 (-> self nav state)))
+      (set! (-> v1-5 speed) (+ 8192.0 (-> self enemy-info-override run-travel-speed)))
+      )
+    0
+    (let ((v1-7 (-> self nav)))
+      (set! (-> v1-7 turning-acceleration) (* 4.0 (-> self enemy-info-override run-turning-acceleration)))
+      )
+    0
+    (set! (-> self root-override2 penetrate-using) (penetrate generic-attack lunge))
+    (enemy-method-49 self)
+    (logior! (-> self focus-status) (focus-status dangerous))
+    (let* ((v1-14 *game-info*)
+           (a0-10 (+ (-> v1-14 attack-id) 1))
+           )
+      (set! (-> v1-14 attack-id) a0-10)
+      (set! (-> self attack-id) a0-10)
+      )
+    (ja-channel-push! 1 (seconds 0.1))
+    (ja :group! spydroid-attack-jump-ja :num! min)
+    (none)
+    )
+  :exit (behavior ()
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (nav-enemy-method-168 self)
+    (let ((v1-4 (-> self nav)))
+      (set! (-> v1-4 target-speed) (-> self enemy-info-override run-travel-speed))
+      )
+    0
+    (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 ()
+    (enemy-method-49 self)
+    nav-state
+    (if (logtest? (-> self enemy-flags) (enemy-flag look-at-focus))
+        (set! (-> self hit-target) (the-as basic #t))
+        )
+    (let ((v1-9 (ja-group)))
+      (cond
+        ((and v1-9 (= v1-9 spydroid-attack-jump-ja))
+         (ja :num! (seek!))
+         (when (ja-done? 0)
+           (let ((v1-20 (-> self nav)))
+             (set! (-> v1-20 target-speed) 0.0)
+             )
+           0
+           (let ((v1-22 (-> self nav)))
+             (set! (-> v1-22 acceleration) 262144.0)
+             )
+           0
+           (let ((v1-24 (-> self nav)))
+             (set! (-> v1-24 turning-acceleration) 0.0)
+             )
+           0
+           (ja :group! spydroid-attack-land-ja :num! min)
+           )
+         )
+        ((let ((v1-32 (ja-group)))
+           (and v1-32 (= v1-32 spydroid-attack-land-ja))
+           )
+         (ja :num! (seek!))
+         (cond
+           ((ja-done? 0)
+            (if (-> self hit-target)
+                (go-virtual victory)
+                (go-hostile self)
+                )
+            )
+           ((not (-> self desire-turn))
+            )
+           ((< 0.0 (-> self diff-angle))
+            (ja-channel-push! 1 (seconds 0.1))
+            (ja :group! spydroid-turn-left-ja :num! min)
+            )
+           (else
+             (ja-channel-push! 1 (seconds 0.1))
+             (ja :group! spydroid-turn-right-ja :num! min)
+             )
+           )
+         )
+        ((let ((v1-58 (ja-group)))
+           (and (and v1-58 (= v1-58 spydroid-turn-left-ja)) (and (-> self desire-turn) (< 0.0 (-> self diff-angle))))
+           )
+         (ja :num! (loop! (* 0.0019975142 (-> self diff-angle))))
+         )
+        (else
+          (let ((v1-68 (ja-group)))
+            (cond
+              ((and (and v1-68 (= v1-68 spydroid-turn-right-ja)) (and (-> self desire-turn) (< (-> self diff-angle) 0.0)))
+               (ja :num! (loop! (* -0.0019975142 (-> self diff-angle))))
+               )
+              ((-> self hit-target)
+               (go-virtual victory)
+               )
+              (else
+                (go-hostile self)
+                )
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior spydroid) sleep-code)
+  :post (the-as (function none :behavior spydroid) nav-enemy-chase-post)
+  )
+
+;; failed to figure out what this is:
+(defstate notice (spydroid)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy notice) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (enemy-method-72 self)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate hostile (spydroid)
+  :virtual #t
+  :trans (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy hostile) trans)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (let ((a0-1 (handle->process (-> self focus handle))))
+      (if (and (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+               (and a0-1 (let ((f0-0 (vector-vector-xz-distance-squared
+                                       (get-trans (the-as process-focusable a0-1) 0)
+                                       (-> self root-override2 trans)
+                                       )
+                                     )
+                               (f1-0 16384.0)
+                               )
+                           (< f0-0 (* f1-0 f1-0))
+                           )
+                    )
+               )
+          (go-virtual attack)
+          )
+      )
+    (cond
+      ((not (-> self desire-turn))
+       (let ((v1-23 (ja-group)))
+         (when (not (and v1-23 (= v1-23 (-> self draw art-group data (-> self enemy-info-override hostile-anim)))))
+           (ja-channel-push! 1 (seconds 0.1))
+           (ja :group! (-> self draw art-group data (-> self enemy-info-override hostile-anim)) :num! min)
+           )
+         )
+       (ja :num! (loop! (/ (-> self nav state speed) (* 0.5 (-> self enemy-info-override run-travel-speed)))))
+       )
+      ((< 0.0 (-> self diff-angle))
+       (let ((v1-43 (ja-group)))
+         (cond
+           ((not (and v1-43 (= v1-43 spydroid-turn-left-ja)))
+            (ja-channel-push! 1 (seconds 0.1))
+            (ja :group! spydroid-turn-left-ja :num! min)
+            )
+           (else
+             (ja :num! (loop! (* 0.0019975142 (-> self diff-angle))))
+             )
+           )
+         )
+       )
+      (else
+        (let ((v1-55 (ja-group)))
+          (cond
+            ((not (and v1-55 (= v1-55 spydroid-turn-right-ja)))
+             (ja-channel-push! 1 (seconds 0.1))
+             (ja :group! spydroid-turn-right-ja :num! min)
+             )
+            (else
+              (ja :num! (loop! (* -0.0019975142 (-> self diff-angle))))
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (logior! (-> self mask) (process-mask sleep-code))
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate circling (spydroid)
+  :virtual #t
+  :trans (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy circling) trans)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (cond
+      ((not (-> self desire-turn))
+       (let ((v1-7 (ja-group)))
+         (when (not (and v1-7 (= v1-7 (-> self draw art-group data (-> self enemy-info-override walk-anim)))))
+           (ja-channel-push! 1 (seconds 0.1))
+           (ja :group! (-> self draw art-group data (-> self enemy-info-override walk-anim)) :num! min)
+           )
+         )
+       (ja :num! (loop! (/ (-> self nav state speed) (* 0.5 (-> self enemy-info-override run-travel-speed)))))
+       )
+      ((< 0.0 (-> self diff-angle))
+       (let ((v1-27 (ja-group)))
+         (cond
+           ((not (and v1-27 (= v1-27 spydroid-turn-left-ja)))
+            (ja-channel-push! 1 (seconds 0.1))
+            (ja :group! spydroid-turn-left-ja :num! min)
+            )
+           (else
+             (ja :num! (loop! (* 0.0019975142 (-> self diff-angle))))
+             )
+           )
+         )
+       )
+      (else
+        (let ((v1-39 (ja-group)))
+          (cond
+            ((not (and v1-39 (= v1-39 spydroid-turn-right-ja)))
+             (ja-channel-push! 1 (seconds 0.1))
+             (ja :group! spydroid-turn-right-ja :num! min)
+             )
+            (else
+              (ja :num! (loop! (* -0.0019975142 (-> self diff-angle))))
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (nav-enemy-method-165 self)
+    (until #f
+      (logior! (-> self mask) (process-mask sleep-code))
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate pacing (spydroid)
+  :virtual #t
+  :trans (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy pacing) trans)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (cond
+      ((not (-> self desire-turn))
+       (let ((v1-7 (ja-group)))
+         (when (not (and v1-7 (= v1-7 (-> self draw art-group data (-> self enemy-info-override walk-anim)))))
+           (ja-channel-push! 1 (seconds 0.1))
+           (ja :group! (-> self draw art-group data (-> self enemy-info-override walk-anim)) :num! min)
+           )
+         )
+       (ja :num! (loop! (/ (-> self nav state speed) (* 0.5 (-> self enemy-info-override run-travel-speed)))))
+       )
+      ((< 0.0 (-> self diff-angle))
+       (let ((v1-27 (ja-group)))
+         (cond
+           ((not (and v1-27 (= v1-27 spydroid-turn-left-ja)))
+            (ja-channel-push! 1 (seconds 0.1))
+            (ja :group! spydroid-turn-left-ja :num! min)
+            )
+           (else
+             (ja :num! (loop! (* 0.0019975142 (-> self diff-angle))))
+             )
+           )
+         )
+       )
+      (else
+        (let ((v1-39 (ja-group)))
+          (cond
+            ((not (and v1-39 (= v1-39 spydroid-turn-right-ja)))
+             (ja-channel-push! 1 (seconds 0.1))
+             (ja :group! spydroid-turn-right-ja :num! min)
+             )
+            (else
+              (ja :num! (loop! (* -0.0019975142 (-> self diff-angle))))
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (logior! (-> self mask) (process-mask sleep-code))
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate stare (spydroid)
+  :virtual #t
+  :trans (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy stare) trans)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (cond
+      ((not (-> self desire-turn))
+       (let ((v1-7 (ja-group)))
+         (when (not (and v1-7 (= v1-7 (-> self draw art-group data (-> self enemy-info-override idle-anim)))))
+           (ja-channel-push! 1 (seconds 0.1))
+           (ja :group! (-> self draw art-group data (-> self enemy-info-override idle-anim)) :num! min)
+           )
+         )
+       (ja :num! (loop!))
+       )
+      ((< 0.0 (-> self diff-angle))
+       (let ((v1-23 (ja-group)))
+         (cond
+           ((not (and v1-23 (= v1-23 spydroid-turn-left-ja)))
+            (ja-channel-push! 1 (seconds 0.1))
+            (ja :group! spydroid-turn-left-ja :num! min)
+            )
+           (else
+             (ja :num! (loop! (* 0.0019975142 (-> self diff-angle))))
+             )
+           )
+         )
+       )
+      (else
+        (let ((v1-35 (ja-group)))
+          (cond
+            ((not (and v1-35 (= v1-35 spydroid-turn-right-ja)))
+             (ja-channel-push! 1 (seconds 0.1))
+             (ja :group! spydroid-turn-right-ja :num! min)
+             )
+            (else
+              (ja :num! (loop! (* -0.0019975142 (-> self diff-angle))))
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (logior! (-> self mask) (process-mask sleep-code))
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  )
+
+;; definition for method 114 of type spydroid
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-114 spydroid ((obj spydroid))
+  "@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 ((v1-7 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-7 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-7 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-7 prim-core action) (collide-action deadly))
+      (set! (-> v1-7 transform-index) 3)
+      (set-vector! (-> v1-7 local-sphere) 0.0 0.0 0.0 4096.0)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) v1-7)
+      )
+    (set! (-> s5-0 nav-radius) 8192.0)
+    (let ((v1-9 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-9 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-9 prim-core collide-with))
+      )
+    (set! (-> obj root-override2) s5-0)
+    )
+  0
+  (none)
+  )
+
+;; definition for method 60 of type spydroid
+(defmethod coin-flip? spydroid ((obj spydroid))
+  "@returns The result of a 50/50 RNG roll"
+  #f
+  )
+
+;; definition for method 10 of type spydroid
+(defmethod deactivate spydroid ((obj spydroid))
+  (if (nonzero? (-> obj explode-part))
+      (kill-and-free-particles (-> obj explode-part))
+      )
+  ((the-as (function process-focusable none) (find-parent-method spydroid 10)) obj)
+  (none)
+  )
+
+;; definition for method 7 of type spydroid
+;; WARN: Return type mismatch nav-enemy vs spydroid.
+(defmethod relocate spydroid ((obj spydroid) (arg0 int))
+  (dotimes (v1-0 4)
+    (if (nonzero? (-> obj lightning v1-0))
+        (&+! (-> obj lightning v1-0) arg0)
+        )
+    )
+  (when (nonzero? (-> obj explode-part))
+    (if (nonzero? (-> obj explode-part))
+        (&+! (-> obj explode-part) arg0)
+        )
+    )
+  (the-as spydroid ((method-of-type nav-enemy relocate) obj arg0))
+  )
+
+;; definition for method 115 of type spydroid
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-115 spydroid ((obj spydroid))
+  "@abstract"
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-spydroid" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (enemy-method-113 obj *spydroid-nav-enemy-info*)
+  (dotimes (s5-1 4)
+    (set! (-> obj lightning s5-1)
+          (new
+            'process
+            'lightning-control
+            (new 'static 'lightning-spec
+              :name #f
+              :flags (lightning-spec-flags lsf0)
+              :start-color (new 'static 'rgba :r #x80 :g #x80 :b #x80 :a #x80)
+              :end-color (new 'static 'rgba :r #x80 :g #x80 :b #x80 :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 8192.0
+              :merge-factor 0.5
+              :merge-count 2
+              :radius 512.0
+              :duration -1.0
+              :sound #f
+              )
+            obj
+            0.0
+            )
+          )
+    (let ((v1-10 (-> obj lightning s5-1))
+          (a0-5 0)
+          )
+      (let ((a1-5 (!= a0-5 (-> v1-10 state mode))))
+        (case a0-5
+          ((3)
+           (if a1-5
+               (set! (-> v1-10 state counter) 0.0)
+               )
+           )
+          ((1)
+           (set! (-> v1-10 state start-color) (-> v1-10 spec start-color))
+           (set! (-> v1-10 state end-color) (-> v1-10 spec end-color))
+           )
+          )
+        )
+      (set! (-> v1-10 state mode) (the-as lightning-mode a0-5))
+      )
+    )
+  (let ((v1-13 (-> obj neck)))
+    (set! (-> v1-13 up) (the-as uint 1))
+    (set! (-> v1-13 nose) (the-as uint 2))
+    (set! (-> v1-13 ear) (the-as uint 0))
+    (set-vector! (-> v1-13 twist-max) 3640.889 11832.889 0.0 1.0)
+    (set! (-> v1-13 ignore-angle) 15473.777)
+    )
+  (set-vector! (-> obj root-override2 scale) 0.5 0.5 0.5 1.0)
+  (let ((v1-17 (-> obj nav)))
+    (set! (-> v1-17 speed-scale) 1.0)
+    )
+  0
+  (set-gravity-length (-> obj root-override2 dynam) 573440.0)
+  (logior! (-> obj nav flags) (nav-control-flag momentum-ignore-heading))
+  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 709) obj))
+  (set! (-> obj explode-part) (create-launch-control (-> *part-group-id-table* 710) obj))
+  (add-connection *part-engine* obj 8 obj 3183 (new 'static 'vector :x -204.8 :y 122.88 :z 1720.32 :w 163840.0))
+  (add-connection
+    *part-engine*
+    obj
+    10
+    obj
+    3183
+    (new 'static 'vector :x -245.76 :y -122.88 :z 901.12 :w 163840.0)
+    )
+  (add-connection *part-engine* obj 4 obj 3184 (new 'static 'vector :x 819.2 :y -122.88 :z 3358.72 :w 163840.0))
+  (add-connection *part-engine* obj 6 obj 3185 (new 'static 'vector :w 163840.0))
+  (add-connection *part-engine* obj 6 obj 3186 (new 'static 'vector :w 163840.0))
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (logclear! (-> obj enemy-flags) (enemy-flag notice))
+  0
+  (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
index 289d86bba8..23f67cd6f0 100644
--- a/test/decompiler/reference/jak2/levels/dig/dig3-obs_REF.gc
+++ b/test/decompiler/reference/jak2/levels/dig/dig3-obs_REF.gc
@@ -243,7 +243,7 @@
 
 ;; definition of type dig-spikey-step
 (deftype dig-spikey-step (process-drawable)
-  ((smush         smush-control :inline :offset-assert 208)
+  ((smush         smush-control :inline :offset-assert 200)
    (init-quat     quaternion    :inline :offset-assert 240)
    (shudder-angle float                 :offset-assert 256)
    (rot-angle     float                 :offset-assert 260)
@@ -268,7 +268,7 @@
   (let ((t9-0 (method-of-type process-drawable inspect)))
     (t9-0 obj)
     )
-  (format #t "~2Tsmush: #<smush-control @ #x~X>~%" (&-> obj stack 72))
+  (format #t "~2Tsmush: #<smush-control @ #x~X>~%" (-> obj smush))
   (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))
@@ -300,26 +300,16 @@
           (suspend)
           )
         )
-      ((method-of-type smush-control activate!)
-       (the-as smush-control (&-> self stack 72))
-       -1.0
-       60
-       225
-       1.0
-       1.0
-       (-> self clock)
-       )
+      (activate! (-> self smush) -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))))
-                )
+          (set! (-> self shudder-angle) (* 364.0889 (update! (-> self smush))))
           (suspend)
           )
         )
       (set! (-> self shudder-angle) 0.0)
-      ((method-of-type smush-control set-zero!) (the-as smush-control (&-> self stack 72)))
+      (set-zero! (-> self smush))
       (let ((gp-4 (-> self clock frame-counter)))
         (until (>= (- (-> self clock frame-counter) gp-4) (seconds 0.25))
           (suspend)
diff --git a/test/decompiler/reference/jak2/levels/drill_platform/ginsu_REF.gc b/test/decompiler/reference/jak2/levels/drill_platform/ginsu_REF.gc
index 25df91a080..b868771ba3 100644
--- a/test/decompiler/reference/jak2/levels/drill_platform/ginsu_REF.gc
+++ b/test/decompiler/reference/jak2/levels/drill_platform/ginsu_REF.gc
@@ -161,20 +161,20 @@
 
 ;; definition of type ginsu
 (deftype ginsu (nav-enemy)
-  ((blade-jm            joint-mod                :offset-assert 604)
-   (blade-speed         cam-float-seeker :inline :offset-assert 608)
-   (blade-angle         float                    :offset-assert 632)
-   (desired-distance    float                    :offset-assert 636)
-   (spiral-time         time-frame               :offset-assert 640)
-   (blade-part          part-spawner             :offset-assert 648)
-   (ambush-path         path-control             :offset-assert 652)
-   (path-pos            float                    :offset-assert 656)
-   (ambush-started      symbol                   :offset-assert 660)
-   (blade-sound         uint32                   :offset-assert 664)
-   (blade-sound-playing symbol                   :offset-assert 668)
-   (grind-sound         uint32                   :offset-assert 672)
-   (grind-sound-playing symbol                   :offset-assert 676)
-   (grind-timer         time-frame               :offset-assert 680)
+  ((blade-jm            joint-mod                        :offset-assert 604)
+   (blade-speed         cam-float-seeker         :inline :offset-assert 608)
+   (blade-angle         float                            :offset-assert 632)
+   (desired-distance    float                            :offset-assert 636)
+   (spiral-time         time-frame                       :offset-assert 640)
+   (blade-part          sparticle-launch-control         :offset-assert 648)
+   (ambush-path         path-control                     :offset-assert 652)
+   (path-pos            float                            :offset-assert 656)
+   (ambush-started      symbol                           :offset-assert 660)
+   (blade-sound         uint32                           :offset-assert 664)
+   (blade-sound-playing symbol                           :offset-assert 668)
+   (grind-sound         uint32                           :offset-assert 672)
+   (grind-sound-playing symbol                           :offset-assert 676)
+   (grind-timer         time-frame                       :offset-assert 680)
    )
   :heap-base #x230
   :method-count-assert 184
@@ -366,8 +366,8 @@
           (vector-negate! (the-as vector (-> s5-0 vector)) (the-as vector (-> s5-0 vector)))
           (set! (-> s5-0 vector 0 w) 0.0)
           )
+        (spawn-with-matrix (-> obj blade-part) s5-0)
         )
-      (run-logic? (-> obj blade-part))
       )
     )
   0
@@ -999,9 +999,11 @@
 
 ;; definition for method 10 of type ginsu
 (defmethod deactivate ginsu ((obj ginsu))
-  (if (nonzero? (-> obj blade-part))
-      ((the-as (function none :behavior part-spawner) (method-of-object (-> obj blade-part) active)))
+  (when (nonzero? (-> obj blade-part))
+    (let ((a0-1 (-> obj blade-part)))
+      ((the-as (function sparticle-launch-control none) (method-of-object a0-1 kill-and-free-particles)) a0-1)
       )
+    )
   (if (-> obj blade-sound-playing)
       (sound-stop (the-as sound-id (-> obj blade-sound)))
       )
@@ -1163,7 +1165,7 @@
   (set! (-> obj blade-jm) (new 'process 'joint-mod (joint-mod-mode joint-set*) obj 8))
   (init (-> obj blade-speed) 1.0 0.01 0.1 0.9)
   (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 475) obj))
-  (set! (-> obj blade-part) (the-as part-spawner (create-launch-control (-> *part-group-id-table* 476) obj)))
+  (set! (-> obj blade-part) (create-launch-control (-> *part-group-id-table* 476) obj))
   (set! (-> obj ambush-path) (new 'process 'curve-control obj 'intro -1000000000.0))
   (set! (-> obj ambush-started) #f)
   (set! (-> obj path-pos) 0.0)
diff --git a/test/decompiler/reference/jak2/levels/mars_tomb/widow-baron_REF.gc b/test/decompiler/reference/jak2/levels/mars_tomb/widow-baron_REF.gc
new file mode 100644
index 0000000000..fd9853f47f
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/mars_tomb/widow-baron_REF.gc
@@ -0,0 +1,1339 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type widow-float-seeker
+(deftype widow-float-seeker (structure)
+  ((target      float  :offset-assert   0)
+   (value       float  :offset-assert   4)
+   (vel         float  :offset-assert   8)
+   (accel       float  :offset-assert  12)
+   (max-vel     float  :offset-assert  16)
+   (max-partial float  :offset-assert  20)
+   (bounce-high float  :offset-assert  24)
+   )
+  :allow-misaligned
+  :method-count-assert 13
+  :size-assert         #x1c
+  :flag-assert         #xd0000001c
+  (:methods
+    (widow-float-seeker-method-9 (_type_ float float float float float) none 9)
+    (widow-float-seeker-method-10 (_type_ (pointer float)) none 10)
+    (widow-float-seeker-method-11 (_type_ float) none 11)
+    (widow-float-seeker-method-12 (_type_ float) none 12)
+    )
+  )
+
+;; definition for method 3 of type widow-float-seeker
+(defmethod inspect widow-float-seeker ((obj widow-float-seeker))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'widow-float-seeker)
+  (format #t "~1Ttarget: ~f~%" (-> obj target))
+  (format #t "~1Tvalue: ~f~%" (-> obj value))
+  (format #t "~1Tvel: ~f~%" (-> obj vel))
+  (format #t "~1Taccel: ~f~%" (-> obj accel))
+  (format #t "~1Tmax-vel: ~f~%" (-> obj max-vel))
+  (format #t "~1Tmax-partial: ~f~%" (-> obj max-partial))
+  (format #t "~1Tbounce-high: ~f~%" (-> obj bounce-high))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for method 9 of type widow-float-seeker
+;; WARN: Return type mismatch int vs none.
+(defmethod widow-float-seeker-method-9 widow-float-seeker ((obj widow-float-seeker) (arg0 float) (arg1 float) (arg2 float) (arg3 float) (arg4 float))
+  (set! (-> obj target) arg0)
+  (set! (-> obj value) arg0)
+  (set! (-> obj vel) 0.0)
+  (set! (-> obj accel) arg1)
+  (set! (-> obj max-vel) arg2)
+  (set! (-> obj max-partial) arg3)
+  (set! (-> obj bounce-high) arg4)
+  0
+  (none)
+  )
+
+;; definition for method 10 of type widow-float-seeker
+;; WARN: Return type mismatch int vs none.
+(defmethod widow-float-seeker-method-10 widow-float-seeker ((obj widow-float-seeker) (arg0 (pointer float)))
+  (set! (-> obj target) (-> arg0 0))
+  (set! (-> obj value) (-> arg0 1))
+  (set! (-> obj vel) (-> arg0 2))
+  (set! (-> obj accel) (-> arg0 3))
+  (set! (-> obj max-vel) (-> arg0 4))
+  (set! (-> obj max-partial) (-> arg0 5))
+  (set! (-> obj bounce-high) (-> arg0 6))
+  0
+  (none)
+  )
+
+;; definition for method 11 of type widow-float-seeker
+;; WARN: Return type mismatch int vs none.
+(defmethod widow-float-seeker-method-11 widow-float-seeker ((obj widow-float-seeker) (arg0 float))
+  (with-pp
+    0.0
+    0.0
+    (let* ((f1-2 (- (+ (-> obj target) arg0) (-> obj value)))
+           (f0-6 (if (= (-> obj target) 0.0)
+                     (* (-> obj max-partial) (fabs f1-2))
+                     (-> obj max-vel)
+                     )
+                 )
+           )
+      (let ((f1-3 (* f1-2 (* (-> obj accel) (-> pp clock time-adjust-ratio)))))
+        (+! (-> obj vel) f1-3)
+        )
+      (let ((f1-6 (fabs (-> obj vel)))
+            (f0-7 (fmin f0-6 (-> obj max-vel)))
+            )
+        (if (< f0-7 f1-6)
+            (set! (-> obj vel) (* (-> obj vel) (/ f0-7 f1-6)))
+            )
+        )
+      )
+    (let ((f0-11 (* (-> obj vel) (-> pp clock time-adjust-ratio))))
+      (+! (-> obj value) f0-11)
+      )
+    (when (and (!= (-> obj target) 0.0) (>= (-> obj value) (-> obj target)) (< 0.0 (-> obj vel)))
+      (set! (-> obj value) (-> obj target))
+      (set! (-> obj vel) (* (-> obj vel) (- (-> obj bounce-high))))
+      )
+    0
+    (none)
+    )
+  )
+
+;; definition for method 12 of type widow-float-seeker
+;; WARN: Return type mismatch int vs none.
+(defmethod widow-float-seeker-method-12 widow-float-seeker ((obj widow-float-seeker) (arg0 float))
+  (set! (-> obj value) (+ (-> obj target) arg0))
+  (set! (-> obj vel) 0.0)
+  0
+  (none)
+  )
+
+;; definition of type widow-rand-vector
+(deftype widow-rand-vector (structure)
+  ((min-time int32          :offset-assert   0)
+   (max-time int32          :offset-assert   4)
+   (xz-max   float          :offset-assert   8)
+   (y-max    float          :offset-assert  12)
+   (timer    int32          :offset-assert  16)
+   (value    vector :inline :offset-assert  32)
+   )
+  :method-count-assert 11
+  :size-assert         #x30
+  :flag-assert         #xb00000030
+  (:methods
+    (init (_type_ int int float float) none 9)
+    (widow-rand-vector-method-10 (_type_) none 10)
+    )
+  )
+
+;; definition for method 3 of type widow-rand-vector
+(defmethod inspect widow-rand-vector ((obj widow-rand-vector))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'widow-rand-vector)
+  (format #t "~1Tmin-time: ~D~%" (-> obj min-time))
+  (format #t "~1Tmax-time: ~D~%" (-> obj max-time))
+  (format #t "~1Txz-max: ~f~%" (-> obj xz-max))
+  (format #t "~1Ty-max: ~f~%" (-> obj y-max))
+  (format #t "~1Ttimer: ~D~%" (-> obj timer))
+  (format #t "~1Tvalue: #<vector @ #x~X>~%" (-> obj value))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for method 9 of type widow-rand-vector
+;; WARN: Return type mismatch int vs none.
+(defmethod init widow-rand-vector ((obj widow-rand-vector) (arg0 int) (arg1 int) (arg2 float) (arg3 float))
+  (set! (-> obj min-time) arg0)
+  (set! (-> obj max-time) arg1)
+  (set! (-> obj xz-max) (* 0.5 arg2))
+  (set! (-> obj y-max) (* 0.5 arg3))
+  (set! (-> obj timer) 0)
+  (vector-reset! (-> obj value))
+  0
+  (none)
+  )
+
+;; definition for method 10 of type widow-rand-vector
+;; WARN: Return type mismatch int vs none.
+(defmethod widow-rand-vector-method-10 widow-rand-vector ((obj widow-rand-vector))
+  (with-pp
+    (set! (-> obj timer)
+          (- (the-as time-frame (-> obj timer)) (- (-> pp clock frame-counter) (-> pp clock old-frame-counter)))
+          )
+    (when (<= (-> obj timer) 0)
+      (set! (-> obj timer) (rand-vu-int-range (-> obj min-time) (-> obj max-time)))
+      (set! (-> obj value x) (rand-vu-float-range (- (-> obj xz-max)) (-> obj xz-max)))
+      (set! (-> obj value y) (rand-vu-float-range (- (-> obj y-max)) (-> obj y-max)))
+      (set! (-> obj value z) (rand-vu-float-range (- (-> obj xz-max)) (-> obj xz-max)))
+      )
+    0
+    (none)
+    )
+  )
+
+;; definition of type widow-oscillator
+(deftype widow-oscillator (structure)
+  ((target  vector :inline :offset-assert   0)
+   (value   vector :inline :offset-assert  16)
+   (vel     vector :inline :offset-assert  32)
+   (accel   float          :offset-assert  48)
+   (max-vel float          :offset-assert  52)
+   (damping float          :offset-assert  56)
+   )
+  :method-count-assert 11
+  :size-assert         #x3c
+  :flag-assert         #xb0000003c
+  (:methods
+    (widow-oscillator-method-9 (_type_ vector float float float) none 9)
+    (widow-oscillator-method-10 (_type_ vector) none 10)
+    )
+  )
+
+;; definition for method 3 of type widow-oscillator
+(defmethod inspect widow-oscillator ((obj widow-oscillator))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'widow-oscillator)
+  (format #t "~1Ttarget: #<vector @ #x~X>~%" (-> obj target))
+  (format #t "~1Tvalue: #<vector @ #x~X>~%" (-> obj value))
+  (format #t "~1Tvel: #<vector @ #x~X>~%" (-> obj vel))
+  (format #t "~1Taccel: ~f~%" (-> obj accel))
+  (format #t "~1Tmax-vel: ~f~%" (-> obj max-vel))
+  (format #t "~1Tdamping: ~f~%" (-> obj damping))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for method 9 of type widow-oscillator
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod widow-oscillator-method-9 widow-oscillator ((obj widow-oscillator) (arg0 vector) (arg1 float) (arg2 float) (arg3 float))
+  (cond
+    (arg0
+      (set! (-> obj target quad) (-> arg0 quad))
+      (set! (-> obj value quad) (-> arg0 quad))
+      )
+    (else
+      (vector-reset! (-> obj target))
+      (vector-reset! (-> obj value))
+      )
+    )
+  (vector-reset! (-> obj vel))
+  (set! (-> obj accel) arg1)
+  (set! (-> obj max-vel) arg2)
+  (set! (-> obj damping) arg3)
+  0
+  (none)
+  )
+
+;; definition for method 10 of type widow-oscillator
+;; WARN: Return type mismatch int vs none.
+(defmethod widow-oscillator-method-10 widow-oscillator ((obj widow-oscillator) (arg0 vector))
+  (with-pp
+    (let ((gp-0 (new 'stack-no-clear 'vector)))
+      (let ((f30-0 (fmax (-> obj max-vel) (vector-length (-> obj vel)))))
+        (cond
+          (arg0
+            (vector+! gp-0 (-> obj target) arg0)
+            (vector-! gp-0 gp-0 (-> obj value))
+            )
+          (else
+            (vector-! gp-0 (-> obj target) (-> obj value))
+            )
+          )
+        (vector-normalize! gp-0 (* (-> obj accel) (-> pp clock time-adjust-ratio)))
+        (vector+! (-> obj vel) (-> obj vel) gp-0)
+        (let ((f0-3 (vector-length (-> obj vel))))
+          (if (< f30-0 f0-3)
+              (vector-float*! (-> obj vel) (-> obj vel) (/ f30-0 f0-3))
+              )
+          )
+        )
+      (vector-float*! (-> obj vel) (-> obj vel) (-> obj damping))
+      (vector-float*! gp-0 (-> obj vel) (-> pp clock time-adjust-ratio))
+      (vector+! (-> obj value) (-> obj value) gp-0)
+      )
+    0
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-widow widow widow-lod0-jg 8
+              ((widow-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 12)
+              :shadow widow-shadow-mg
+              :origin-joint-index 3
+              )
+
+;; definition of type widow-shot
+(deftype widow-shot (guard-shot)
+  ()
+  :heap-base #x170
+  :method-count-assert 40
+  :size-assert         #x1f0
+  :flag-assert         #x28017001f0
+  )
+
+;; definition for method 3 of type widow-shot
+(defmethod inspect widow-shot ((obj widow-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 of type widow
+(deftype widow (process-drawable)
+  ((bomb                         handle                   8       :offset-assert 200)
+   (next-launch                  int32                            :offset-assert 264)
+   (launch-dest                  vector                   :inline :offset-assert 272)
+   (next-jumper                  int32                            :offset-assert 288)
+   (ammos                        handle                   2       :offset-assert 296)
+   (ammo-timers                  time-frame               2       :offset-assert 312)
+   (bomb-hits                    int32                            :offset-assert 328)
+   (circle-center                vector                   :inline :offset-assert 336)
+   (theta                        cam-float-seeker         :inline :offset-assert 352)
+   (traj                         trajectory               :inline :offset-assert 384)
+   (osc                          widow-oscillator         :inline :offset-assert 432)
+   (noise-osc                    widow-oscillator         :inline :offset-assert 496)
+   (rand-vec                     widow-rand-vector        :inline :offset-assert 560)
+   (attack-from-high-deg         symbol                           :offset-assert 608)
+   (which-gun                    int32                            :offset-assert 612)
+   (which-pod                    int32                            :offset-assert 616)
+   (left-cover-angle             widow-float-seeker       :inline :offset        620)
+   (right-cover-angle            widow-float-seeker       :inline :offset        648)
+   (left-cover-jm                joint-mod                        :offset-assert 676)
+   (right-cover-jm               joint-mod                        :offset-assert 680)
+   (drill-speed                  cam-float-seeker         :inline :offset-assert 684)
+   (drill-angle                  float                            :offset-assert 708)
+   (left-drill-jm                joint-mod                        :offset-assert 712)
+   (right-drill-jm               joint-mod                        :offset-assert 716)
+   (flying                       symbol                           :offset-assert 720)
+   (previous-anim                int32                            :offset-assert 724)
+   (launched-a-bomb              symbol                           :offset-assert 728)
+   (old-bomb-hits                int32                            :offset-assert 732)
+   (catwalk                      handle                   8       :offset-assert 736)
+   (heart                        handle                           :offset-assert 800)
+   (pod                          handle                           :offset-assert 808)
+   (baron                        (pointer manipy)                 :offset-assert 816)
+   (drill-spark-part             sparticle-launch-control         :offset-assert 820)
+   (drill-spark-part-alt         sparticle-launch-control         :offset-assert 824)
+   (extract-stone-time           time-frame                       :offset-assert 832)
+   (extract-stone-part           sparticle-launch-control         :offset-assert 840)
+   (insert-stone-time            time-frame                       :offset-assert 848)
+   (insert-stone-part            sparticle-launch-control         :offset-assert 856)
+   (land-part                    sparticle-launch-control         :offset-assert 860)
+   (green-charge-part            sparticle-launch-control         :offset-assert 864)
+   (green-fire-part              sparticle-launch-control         :offset-assert 868)
+   (lightning                    lightning-control        5       :offset-assert 872)
+   (stop-catwalk-sound           symbol                           :offset-assert 892)
+   (catwalk-sound                uint32                           :offset-assert 896)
+   (drill-sound                  uint32                           :offset-assert 900)
+   (drill-sound-playing          symbol                           :offset-assert 904)
+   (drill-sweeten-sound          uint32                           :offset-assert 908)
+   (drill-sweeten-sound-playing  symbol                           :offset-assert 912)
+   (movie-handle                 handle                           :offset-assert 920)
+   (tilt                         cam-float-seeker         :inline :offset-assert 928)
+   (targetted-catwalk            int32                            :offset-assert 952)
+   (hover-sound                  uint32                           :offset-assert 956)
+   (hover-sound-playing          symbol                           :offset-assert 960)
+   (shake-sound                  uint32                           :offset-assert 964)
+   (shake-sound-playing          symbol                           :offset-assert 968)
+   (hud                          handle                           :offset-assert 976)
+   (last-want-stone-talker       int8                             :offset-assert 984)
+   (last-general-flying-talker   int8                             :offset-assert 985)
+   (last-launch-droids-talker    int8                             :offset-assert 986)
+   (last-launch-bombs-talker     int8                             :offset-assert 987)
+   (last-shoot-gun-talker        int8                             :offset-assert 988)
+   (last-stone-charge-up-talker  int8                             :offset-assert 989)
+   (last-after-stone-shot-talker int8                             :offset-assert 990)
+   (last-leave-perch-talker      int8                             :offset-assert 991)
+   (last-damaged-talker          int8                             :offset-assert 992)
+   (kicked-bombs                 int8                             :offset-assert 993)
+   (launch-stages-completed      int8                             :offset-assert 994)
+   (current-shoot-stage          int16                            :offset-assert 996)
+   (last-gun-hit-stage           int16                            :offset-assert 998)
+   (gun-hits                     int16                            :offset-assert 1000)
+   (last-attack-id               uint32                           :offset-assert 1004)
+   )
+  :heap-base #x370
+  :method-count-assert 47
+  :size-assert         #x3f0
+  :flag-assert         #x2f037003f0
+  (:methods
+    (beaten () _type_ :state 20)
+    (kaboom () _type_ :state 21)
+    (hover-low-stage-3 () _type_ :state 22)
+    (hover-shooting-stage-3 () _type_ :state 23)
+    (hover-launch-bombs-stage-3 () _type_ :state 24)
+    (hover-big-blast-stage-3 () _type_ :state 25)
+    (hover-rise-stage-3 () _type_ :state 26)
+    (hover-jump-down-stage-3 () _type_ :state 27)
+    (big-reaction-stage-2 () _type_ :state 28)
+    (watch-bombs-stage-2 () _type_ :state 29)
+    (launch-bombs-stage-2 () _type_ :state 30)
+    (back-to-perch-stage-2 () _type_ :state 31)
+    (hover-low-stage-2 () _type_ :state 32)
+    (hover-shooting-stage-2 () _type_ :state 33)
+    (hover-rise-stage-2 () _type_ :state 34)
+    (hover-seek-under-stage-2 () _type_ :state 35)
+    (hover-jump-down-stage-2 () _type_ :state 36)
+    (launch-droids-stage-2 () _type_ :state 37)
+    (big-reaction-stage-1 () _type_ :state 38)
+    (watch-bombs-stage-1 () _type_ :state 39)
+    (launch-bombs-stage-1 () _type_ :state 40)
+    (watch-droids-stage-1 () _type_ :state 41)
+    (launch-droids-stage-1 () _type_ :state 42)
+    (hidden () _type_ :state 43)
+    (widow-method-44 (_type_ vector vector) symbol 44)
+    (widow-method-45 (_type_ vector vector vector) none 45)
+    (widow-method-46 (_type_ vector int) none 46)
+    )
+  )
+
+;; definition for method 3 of type widow
+(defmethod inspect widow ((obj widow))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tbomb[8] @ #x~X~%" (-> obj bomb))
+  (format #t "~2Tnext-launch: ~D~%" (-> obj next-launch))
+  (format #t "~2Tlaunch-dest: #<vector @ #x~X>~%" (-> obj launch-dest))
+  (format #t "~2Tnext-jumper: ~D~%" (-> obj next-jumper))
+  (format #t "~2Tammos[2] @ #x~X~%" (-> obj ammos))
+  (format #t "~2Tammo-timers[2] @ #x~X~%" (-> obj ammo-timers))
+  (format #t "~2Tbomb-hits: ~D~%" (-> obj bomb-hits))
+  (format #t "~2Tcircle-center: #<vector @ #x~X>~%" (-> obj circle-center))
+  (format #t "~2Ttheta: #<cam-float-seeker @ #x~X>~%" (-> obj theta))
+  (format #t "~2Ttraj: #<trajectory @ #x~X>~%" (-> obj traj))
+  (format #t "~2Tosc: #<widow-oscillator @ #x~X>~%" (-> obj osc))
+  (format #t "~2Tnoise-osc: #<widow-oscillator @ #x~X>~%" (-> obj noise-osc))
+  (format #t "~2Trand-vec: #<widow-rand-vector @ #x~X>~%" (-> obj rand-vec))
+  (format #t "~2Tattack-from-high-deg: ~A~%" (-> obj attack-from-high-deg))
+  (format #t "~2Twhich-gun: ~D~%" (-> obj which-gun))
+  (format #t "~2Twhich-pod: ~D~%" (-> obj which-pod))
+  (format #t "~2Tleft-cover-angle: #<widow-float-seeker @ #x~X>~%" (-> obj left-cover-angle))
+  (format #t "~2Tright-cover-angle: #<widow-float-seeker @ #x~X>~%" (-> obj right-cover-angle))
+  (format #t "~2Tleft-cover-jm: ~A~%" (-> obj left-cover-jm))
+  (format #t "~2Tright-cover-jm: ~A~%" (-> obj right-cover-jm))
+  (format #t "~2Tdrill-speed: #<cam-float-seeker @ #x~X>~%" (-> obj drill-speed))
+  (format #t "~2Tdrill-angle: ~f~%" (-> obj drill-angle))
+  (format #t "~2Tleft-drill-jm: ~A~%" (-> obj left-drill-jm))
+  (format #t "~2Tright-drill-jm: ~A~%" (-> obj right-drill-jm))
+  (format #t "~2Tflying: ~A~%" (-> obj flying))
+  (format #t "~2Tprevious-anim: ~D~%" (-> obj previous-anim))
+  (format #t "~2Tlaunched-a-bomb: ~A~%" (-> obj launched-a-bomb))
+  (format #t "~2Told-bomb-hits: ~D~%" (-> obj old-bomb-hits))
+  (format #t "~2Tcatwalk[8] @ #x~X~%" (-> obj catwalk))
+  (format #t "~2Theart: ~D~%" (-> obj heart))
+  (format #t "~2Tpod: ~D~%" (-> obj pod))
+  (format #t "~2Tbaron: #x~X~%" (-> obj baron))
+  (format #t "~2Tdrill-spark-part: ~A~%" (-> obj drill-spark-part))
+  (format #t "~2Tdrill-spark-part-alt: ~A~%" (-> obj drill-spark-part-alt))
+  (format #t "~2Textract-stone-time: ~D~%" (-> obj extract-stone-time))
+  (format #t "~2Textract-stone-part: ~A~%" (-> obj extract-stone-part))
+  (format #t "~2Tinsert-stone-time: ~D~%" (-> obj insert-stone-time))
+  (format #t "~2Tinsert-stone-part: ~A~%" (-> obj insert-stone-part))
+  (format #t "~2Tland-part: ~A~%" (-> obj land-part))
+  (format #t "~2Tgreen-charge-part: ~A~%" (-> obj green-charge-part))
+  (format #t "~2Tgreen-fire-part: ~A~%" (-> obj green-fire-part))
+  (format #t "~2Tlightning[5] @ #x~X~%" (-> obj lightning))
+  (format #t "~2Tstop-catwalk-sound: ~A~%" (-> obj stop-catwalk-sound))
+  (format #t "~2Tcatwalk-sound: ~D~%" (-> obj catwalk-sound))
+  (format #t "~2Tdrill-sound: ~D~%" (-> obj drill-sound))
+  (format #t "~2Tdrill-sound-playing: ~A~%" (-> obj drill-sound-playing))
+  (format #t "~2Tdrill-sweeten-sound: ~D~%" (-> obj drill-sweeten-sound))
+  (format #t "~2Tdrill-sweeten-sound-playing: ~A~%" (-> obj drill-sweeten-sound-playing))
+  (format #t "~2Tmovie-handle: ~D~%" (-> obj movie-handle))
+  (format #t "~2Ttilt: #<cam-float-seeker @ #x~X>~%" (-> obj tilt))
+  (format #t "~2Ttargetted-catwalk: ~D~%" (-> obj targetted-catwalk))
+  (format #t "~2Thover-sound: ~D~%" (-> obj hover-sound))
+  (format #t "~2Thover-sound-playing: ~A~%" (-> obj hover-sound-playing))
+  (format #t "~2Tshake-sound: ~D~%" (-> obj shake-sound))
+  (format #t "~2Tshake-sound-playing: ~A~%" (-> obj shake-sound-playing))
+  (format #t "~2Thud: ~D~%" (-> obj hud))
+  (format #t "~2Tlast-want-stone-talker: ~D~%" (-> obj last-want-stone-talker))
+  (format #t "~2Tlast-general-flying-talker: ~D~%" (-> obj last-general-flying-talker))
+  (format #t "~2Tlast-launch-droids-talker: ~D~%" (-> obj last-launch-droids-talker))
+  (format #t "~2Tlast-launch-bombs-talker: ~D~%" (-> obj last-launch-bombs-talker))
+  (format #t "~2Tlast-shoot-gun-talker: ~D~%" (-> obj last-shoot-gun-talker))
+  (format #t "~2Tlast-stone-charge-up-talker: ~D~%" (-> obj last-stone-charge-up-talker))
+  (format #t "~2Tlast-after-stone-shot-talker: ~D~%" (-> obj last-after-stone-shot-talker))
+  (format #t "~2Tlast-leave-perch-talker: ~D~%" (-> obj last-leave-perch-talker))
+  (format #t "~2Tlast-damaged-talker: ~D~%" (-> obj last-damaged-talker))
+  (format #t "~2Tkicked-bombs: ~D~%" (-> obj kicked-bombs))
+  (format #t "~2Tlaunch-stages-completed: ~D~%" (-> obj launch-stages-completed))
+  (format #t "~2Tcurrent-shoot-stage: ~D~%" (-> obj current-shoot-stage))
+  (format #t "~2Tlast-gun-hit-stage: ~D~%" (-> obj last-gun-hit-stage))
+  (format #t "~2Tgun-hits: ~D~%" (-> obj gun-hits))
+  (format #t "~2Tlast-attack-id: ~D~%" (-> obj last-attack-id))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type baron-pod
+(deftype baron-pod (process-drawable)
+  ((red-tip-change-time time-frame  :offset-assert 200)
+   (alt-red-tip-on      symbol      :offset-assert 208)
+   (blink-time          time-frame  :offset-assert 216)
+   (blink-mask          int32       :offset-assert 224)
+   (has-stone           symbol      :offset-assert 228)
+   )
+  :heap-base #x70
+  :method-count-assert 22
+  :size-assert         #xe8
+  :flag-assert         #x16007000e8
+  (:methods
+    (idle () _type_ :state 20)
+    (baron-pod-method-21 (_type_ symbol) none 21)
+    )
+  )
+
+;; definition for method 3 of type baron-pod
+(defmethod inspect baron-pod ((obj baron-pod))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tred-tip-change-time: ~D~%" (-> obj red-tip-change-time))
+  (format #t "~2Talt-red-tip-on: ~A~%" (-> obj alt-red-tip-on))
+  (format #t "~2Tblink-time: ~D~%" (-> obj blink-time))
+  (format #t "~2Tblink-mask: ~D~%" (-> obj blink-mask))
+  (format #t "~2Thas-stone: ~A~%" (-> obj has-stone))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-baron-pod baron-pod baron-pod-lod0-jg baron-pod-idle-ja
+              ((baron-pod-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 3)
+              :shadow baron-pod-shadow-mg
+              :origin-joint-index 3
+              )
+
+;; definition for method 21 of type baron-pod
+;; WARN: Return type mismatch int vs none.
+(defmethod baron-pod-method-21 baron-pod ((obj baron-pod) (arg0 symbol))
+  (with-pp
+    (when (>= (- (-> pp clock frame-counter) (-> obj red-tip-change-time)) 0)
+      (set! (-> obj alt-red-tip-on) (not (-> obj alt-red-tip-on)))
+      (set! (-> obj red-tip-change-time) (+ (-> pp clock frame-counter) (seconds 0.5)))
+      (set! arg0 #t)
+      )
+    (when (>= (- (-> pp clock frame-counter) (-> obj blink-time)) 0)
+      (set! (-> obj blink-mask) 0)
+      (dotimes (s5-0 10)
+        (let* ((f30-0 0.5)
+               (v1-17 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+               (v1-18 (the-as number (logior #x3f800000 v1-17)))
+               )
+          (if (< f30-0 (+ -1.0 (the-as float v1-18)))
+              (logior! (-> obj blink-mask) (ash 1 s5-0))
+              )
+          )
+        )
+      (set! (-> obj blink-time) (+ (-> pp clock frame-counter) (the int (* 300.0 (rand-vu-float-range 0.25 0.75)))))
+      (set! arg0 #t)
+      )
+    (when arg0
+      (remove-from-process *part-engine* obj)
+      (add-connection *part-engine* obj 13 obj 3264 (new 'static 'vector :w 819200.0))
+      (add-connection *part-engine* obj 14 obj 3264 (new 'static 'vector :w 819200.0))
+      (if (-> obj alt-red-tip-on)
+          (add-connection *part-engine* obj 5 obj 3251 (new 'static 'vector :w 819200.0))
+          (add-connection *part-engine* obj 6 obj 3251 (new 'static 'vector :w 819200.0))
+          )
+      (let ((s5-2 (-> obj blink-mask)))
+        (if (logtest? s5-2 1)
+            (add-connection *part-engine* obj 8 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        (if (logtest? s5-2 2)
+            (add-connection *part-engine* obj 9 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        (if (logtest? s5-2 4)
+            (add-connection *part-engine* obj 10 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        (if (logtest? s5-2 8)
+            (add-connection *part-engine* obj 11 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        (if (logtest? s5-2 16)
+            (add-connection *part-engine* obj 12 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        (if (logtest? s5-2 32)
+            (add-connection *part-engine* obj 15 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        (if (logtest? s5-2 64)
+            (add-connection *part-engine* obj 16 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        (if (logtest? s5-2 128)
+            (add-connection *part-engine* obj 17 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        (if (logtest? s5-2 256)
+            (add-connection *part-engine* obj 18 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        (if (logtest? s5-2 512)
+            (add-connection *part-engine* obj 19 obj 3252 (new 'static 'vector :w 819200.0))
+            )
+        )
+      (cond
+        ((-> obj has-stone)
+         (add-connection *part-engine* obj 4 obj 3258 (new 'static 'vector :y 4096.0 :w 819200.0))
+         (add-connection *part-engine* obj 4 obj 3259 (new 'static 'vector :y 4096.0 :w 819200.0))
+         )
+        (else
+          (add-connection *part-engine* obj 4 obj 3256 (new 'static 'vector :y 4096.0 :w 819200.0))
+          (add-connection *part-engine* obj 4 obj 3257 (new 'static 'vector :y 4096.0 :w 819200.0))
+          )
+        )
+      )
+    (if (-> obj has-stone)
+        (spawn (-> obj part) (-> obj root trans))
+        )
+    0
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate idle (baron-pod)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as object (case event-type
+                     (('frame)
+                      (let ((v1-3 (ja-group)))
+                        (when (not (and v1-3 (= v1-3 (-> self draw art-group data 4))))
+                          (ja :group! (-> self draw art-group data 4) :num! min)
+                          (set! (-> self draw bounds w) 81920.0)
+                          )
+                        )
+                      (when (and (< (ja-aframe-num 0) 834.0) (>= (the-as float (-> event param 0)) 834.0))
+                        (setup-masks (-> self draw) 4 2)
+                        (set! (-> self has-stone) #t)
+                        (the-as symbol (baron-pod-method-21 self #t))
+                        )
+                      )
+                     (('finale)
+                      (the-as symbol (setup-masks (-> self draw) 8 0))
+                      )
+                     )
+            )
+    )
+  :trans (behavior ()
+    (baron-pod-method-21 self #f)
+    (none)
+    )
+  :code (the-as (function none :behavior baron-pod) sleep-code)
+  :post (the-as (function none :behavior baron-pod) transform-post)
+  )
+
+;; definition for function baron-pod-init-by-other
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defbehavior baron-pod-init-by-other baron-pod ((arg0 vector))
+  (let ((s5-0 (new 'process 'collide-shape-moving self (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)
+          )
+    (set! (-> s5-0 penetrated-by) (the-as penetrate -1))
+    (let ((v1-7 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-7 transform-index) 3)
+      (set-vector! (-> v1-7 local-sphere) 0.0 0.0 9216.0 4096.0)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) v1-7)
+      )
+    (set! (-> s5-0 nav-radius) 8192.0)
+    (let ((v1-9 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-9 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-9 prim-core collide-with))
+      )
+    (set! (-> self root) s5-0)
+    )
+  (set! (-> self root trans quad) (-> arg0 quad))
+  (initialize-skeleton
+    self
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-baron-pod" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (setup-masks (-> self draw) 0 12)
+  (set! (-> self root pause-adjust-distance) 245760.0)
+  (let ((v1-21 (-> self node-list data)))
+    (set! (-> v1-21 0 param0) (the-as (function cspace transformq none) cspace<-parent-joint!))
+    (set! (-> v1-21 0 param1) (the-as basic (-> self parent)))
+    (set! (-> v1-21 0 param2) (the-as basic 3))
+    )
+  (set! (-> self blink-time) 0)
+  (set! (-> self red-tip-change-time) 0)
+  (set! (-> self has-stone) #f)
+  (set! (-> self part) (create-launch-control (-> *part-group-id-table* 728) self))
+  (baron-pod-method-21 self #t)
+  (go-virtual idle)
+  (none)
+  )
+
+;; definition of type tomb-boss-bridge
+(deftype tomb-boss-bridge (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 tomb-boss-bridge
+(defmethod inspect tomb-boss-bridge ((obj tomb-boss-bridge))
+  (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:
+(defstate idle (tomb-boss-bridge)
+  :virtual #t
+  :trans (behavior ()
+    (when (task-node-closed? (game-task-node tomb-boss-introduction))
+      (cleanup-for-death self)
+      (deactivate self)
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior tomb-boss-bridge) sleep-code)
+  )
+
+;; definition for method 11 of type tomb-boss-bridge
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! tomb-boss-bridge ((obj tomb-boss-bridge) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (case ((method-of-type res-lump get-property-struct)
+         (-> obj entity)
+         'tomb-boss-bridge-type
+         'interp
+         -1000000000.0
+         (the-as structure 'a)
+         (the-as (pointer res-tag) #f)
+         *res-static-buf*
+         )
+    (('b)
+     (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-tomb-boss-bridge-b" (the-as (pointer uint32) #f)))
+       (the-as pair 0)
+       )
+     )
+    (else
+      (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-tomb-boss-bridge-a" (the-as (pointer uint32) #f)))
+        (the-as pair 0)
+        )
+      )
+    )
+  (set! (-> obj draw light-index) (the-as uint 2))
+  (ja-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition for function widow-want-stone-talker
+(defbehavior widow-want-stone-talker widow ()
+  (if (or (>= (-> self bomb-hits) 4) (let* ((f30-0 0.001)
+                                            (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                                            (v1-5 (the-as number (logior #x3f800000 v1-4)))
+                                            )
+                                       (< f30-0 (+ -1.0 (the-as float v1-5)))
+                                       )
+          )
+      (return (the-as int #f))
+      )
+  (let ((v1-9 (rand-vu-int-count 5)))
+    (if (>= v1-9 (-> self last-want-stone-talker))
+        (+! v1-9 1)
+        )
+    (set! (-> self last-want-stone-talker) v1-9)
+    (cond
+      ((zero? v1-9)
+       (talker-spawn-func (-> *talker-speech* 241) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 1)
+       (talker-spawn-func (-> *talker-speech* 242) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 2)
+       (talker-spawn-func (-> *talker-speech* 243) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 3)
+       (talker-spawn-func (-> *talker-speech* 244) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 4)
+       (talker-spawn-func (-> *talker-speech* 245) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 5)
+       (talker-spawn-func (-> *talker-speech* 246) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      )
+    )
+  )
+
+;; definition for function widow-general-flying-talker
+(defbehavior widow-general-flying-talker widow ()
+  (if (or (>= (-> self bomb-hits) 4) (let* ((f30-0 0.002)
+                                            (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                                            (v1-5 (the-as number (logior #x3f800000 v1-4)))
+                                            )
+                                       (< f30-0 (+ -1.0 (the-as float v1-5)))
+                                       )
+          )
+      (return (the-as int #f))
+      )
+  (let ((v1-9 (rand-vu-int-count 4)))
+    (if (>= v1-9 (-> self last-general-flying-talker))
+        (+! v1-9 1)
+        )
+    (set! (-> self last-general-flying-talker) v1-9)
+    (cond
+      ((zero? v1-9)
+       (talker-spawn-func (-> *talker-speech* 273) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 1)
+       (talker-spawn-func (-> *talker-speech* 288) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 2)
+       (talker-spawn-func (-> *talker-speech* 289) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 3)
+       (talker-spawn-func (-> *talker-speech* 290) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 4)
+       (talker-spawn-func (-> *talker-speech* 291) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      )
+    )
+  )
+
+;; definition for function widow-launch-droids-talker
+(defbehavior widow-launch-droids-talker widow ()
+  (if (or (>= (-> self bomb-hits) 4) (let* ((f30-0 0.9)
+                                            (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                                            (v1-5 (the-as number (logior #x3f800000 v1-4)))
+                                            )
+                                       (< f30-0 (+ -1.0 (the-as float v1-5)))
+                                       )
+          )
+      (return (the-as int #f))
+      )
+  (let ((v1-9 (rand-vu-int-count 4)))
+    (if (>= v1-9 (-> self last-launch-droids-talker))
+        (+! v1-9 1)
+        )
+    (set! (-> self last-launch-droids-talker) v1-9)
+    (cond
+      ((zero? v1-9)
+       (talker-spawn-func (-> *talker-speech* 247) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 1)
+       (talker-spawn-func (-> *talker-speech* 248) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 2)
+       (talker-spawn-func (-> *talker-speech* 249) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 3)
+       (talker-spawn-func (-> *talker-speech* 250) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 4)
+       (talker-spawn-func (-> *talker-speech* 299) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      )
+    )
+  )
+
+;; definition for function widow-launch-bombs-talker
+(defbehavior widow-launch-bombs-talker widow ()
+  (if (or (>= (-> self bomb-hits) 4) (let* ((f30-0 0.9)
+                                            (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                                            (v1-5 (the-as number (logior #x3f800000 v1-4)))
+                                            )
+                                       (< f30-0 (+ -1.0 (the-as float v1-5)))
+                                       )
+          )
+      (return (the-as int #f))
+      )
+  (let ((v1-9 (rand-vu-int-count 5)))
+    (if (>= v1-9 (-> self last-launch-bombs-talker))
+        (+! v1-9 1)
+        )
+    (set! (-> self last-launch-bombs-talker) v1-9)
+    (cond
+      ((zero? v1-9)
+       (talker-spawn-func (-> *talker-speech* 251) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 1)
+       (talker-spawn-func (-> *talker-speech* 252) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 2)
+       (talker-spawn-func (-> *talker-speech* 255) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 3)
+       (talker-spawn-func (-> *talker-speech* 256) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 4)
+       (talker-spawn-func (-> *talker-speech* 267) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 5)
+       (talker-spawn-func (-> *talker-speech* 272) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      )
+    )
+  )
+
+;; definition for function widow-shoot-gun-talker
+(defbehavior widow-shoot-gun-talker widow ()
+  (if (or (>= (-> self bomb-hits) 4) (let* ((f30-0 0.7)
+                                            (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                                            (v1-5 (the-as number (logior #x3f800000 v1-4)))
+                                            )
+                                       (< f30-0 (+ -1.0 (the-as float v1-5)))
+                                       )
+          )
+      (return (the-as int #f))
+      )
+  (let ((v1-9 (rand-vu-int-count 10)))
+    (if (>= v1-9 (-> self last-shoot-gun-talker))
+        (+! v1-9 1)
+        )
+    (set! (-> self last-shoot-gun-talker) v1-9)
+    (cond
+      ((zero? v1-9)
+       (talker-spawn-func (-> *talker-speech* 253) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 1)
+       (talker-spawn-func (-> *talker-speech* 254) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 2)
+       (talker-spawn-func (-> *talker-speech* 257) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 3)
+       (talker-spawn-func (-> *talker-speech* 258) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 4)
+       (talker-spawn-func (-> *talker-speech* 286) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 5)
+       (talker-spawn-func (-> *talker-speech* 268) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 6)
+       (talker-spawn-func (-> *talker-speech* 269) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 7)
+       (talker-spawn-func (-> *talker-speech* 292) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 8)
+       (talker-spawn-func (-> *talker-speech* 293) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 9)
+       (talker-spawn-func (-> *talker-speech* 300) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 10)
+       (talker-spawn-func (-> *talker-speech* 274) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      )
+    )
+  )
+
+;; definition for function widow-stone-charge-up-talker
+(defbehavior widow-stone-charge-up-talker widow ()
+  (if (or (>= (-> self bomb-hits) 4) (let* ((f30-0 0.6)
+                                            (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                                            (v1-5 (the-as number (logior #x3f800000 v1-4)))
+                                            )
+                                       (< f30-0 (+ -1.0 (the-as float v1-5)))
+                                       )
+          )
+      (return (the-as int #f))
+      )
+  (let ((v1-9 (rand-vu-int-count 5)))
+    (if (>= v1-9 (-> self last-stone-charge-up-talker))
+        (+! v1-9 1)
+        )
+    (set! (-> self last-stone-charge-up-talker) v1-9)
+    (cond
+      ((zero? v1-9)
+       (talker-spawn-func (-> *talker-speech* 259) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 1)
+       (talker-spawn-func (-> *talker-speech* 260) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 2)
+       (talker-spawn-func (-> *talker-speech* 264) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 3)
+       (talker-spawn-func (-> *talker-speech* 296) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 4)
+       (talker-spawn-func (-> *talker-speech* 298) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 5)
+       (talker-spawn-func (-> *talker-speech* 266) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      )
+    )
+  )
+
+;; definition for function widow-after-stone-shot-talker
+(defbehavior widow-after-stone-shot-talker widow ()
+  (if (or (>= (-> self bomb-hits) 4) (let* ((f30-0 0.6)
+                                            (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                                            (v1-5 (the-as number (logior #x3f800000 v1-4)))
+                                            )
+                                       (< f30-0 (+ -1.0 (the-as float v1-5)))
+                                       )
+          )
+      (return (the-as int #f))
+      )
+  (let ((v1-9 (rand-vu-int-count 5)))
+    (if (>= v1-9 (-> self last-after-stone-shot-talker))
+        (+! v1-9 1)
+        )
+    (set! (-> self last-after-stone-shot-talker) v1-9)
+    (cond
+      ((zero? v1-9)
+       (talker-spawn-func (-> *talker-speech* 261) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 1)
+       (talker-spawn-func (-> *talker-speech* 262) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 2)
+       (talker-spawn-func (-> *talker-speech* 263) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 3)
+       (talker-spawn-func (-> *talker-speech* 297) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 4)
+       (talker-spawn-func (-> *talker-speech* 271) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 5)
+       (talker-spawn-func (-> *talker-speech* 265) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      )
+    )
+  )
+
+;; definition for function widow-leave-perch-talker
+(defbehavior widow-leave-perch-talker widow ()
+  (if (or (>= (-> self bomb-hits) 4) (let* ((f30-0 0.4)
+                                            (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                                            (v1-5 (the-as number (logior #x3f800000 v1-4)))
+                                            )
+                                       (< f30-0 (+ -1.0 (the-as float v1-5)))
+                                       )
+          )
+      (return (the-as int #f))
+      )
+  (let ((v1-9 (rand-vu-int-count 4)))
+    (if (>= v1-9 (-> self last-leave-perch-talker))
+        (+! v1-9 1)
+        )
+    (set! (-> self last-leave-perch-talker) v1-9)
+    (cond
+      ((zero? v1-9)
+       (talker-spawn-func (-> *talker-speech* 270) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 1)
+       (talker-spawn-func (-> *talker-speech* 277) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 2)
+       (talker-spawn-func (-> *talker-speech* 275) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 3)
+       (talker-spawn-func (-> *talker-speech* 276) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-9 4)
+       (talker-spawn-func (-> *talker-speech* 285) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      )
+    )
+  )
+
+;; definition for function widow-damaged-talker
+(defbehavior widow-damaged-talker widow ()
+  (let* ((f30-0 0.99)
+         (v1-2 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+         (v1-3 (the-as number (logior #x3f800000 v1-2)))
+         )
+    (if (< f30-0 (+ -1.0 (the-as float v1-3)))
+        (return (the-as int #f))
+        )
+    )
+  (let ((v1-7 (rand-vu-int-count 11)))
+    (if (>= v1-7 (-> self last-damaged-talker))
+        (+! v1-7 1)
+        )
+    (set! (-> self last-damaged-talker) v1-7)
+    (cond
+      ((zero? v1-7)
+       (talker-spawn-func (-> *talker-speech* 278) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 1)
+       (talker-spawn-func (-> *talker-speech* 279) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 2)
+       (talker-spawn-func (-> *talker-speech* 280) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 3)
+       (talker-spawn-func (-> *talker-speech* 281) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 4)
+       (talker-spawn-func (-> *talker-speech* 282) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 5)
+       (talker-spawn-func (-> *talker-speech* 283) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 6)
+       (talker-spawn-func (-> *talker-speech* 284) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 7)
+       (talker-spawn-func (-> *talker-speech* 294) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 8)
+       (talker-spawn-func (-> *talker-speech* 295) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 9)
+       (talker-spawn-func (-> *talker-speech* 287) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 10)
+       (talker-spawn-func (-> *talker-speech* 307) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      ((= v1-7 11)
+       (talker-spawn-func (-> *talker-speech* 304) *entity-pool* (target-pos 0) (the-as region #f))
+       )
+      )
+    )
+  )
+
+;; definition for function widow-handler
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch none vs object.
+(defbehavior widow-handler widow ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (local-vars (v0-0 object) (sv-224 symbol) (sv-240 symbol) (sv-256 vector) (sv-272 matrix))
+  (the-as
+    object
+    (case arg2
+      (('attack)
+       (let ((v1-1 (the-as object (-> arg3 param 1))))
+         (when (and (logtest? (attack-info-mask penetrate-using) (-> (the-as attack-info v1-1) mask))
+                    (logtest? (penetrate dark-bomb) (-> (the-as attack-info v1-1) penetrate-using))
+                    (!= (-> self last-attack-id) (-> (the-as attack-info v1-1) id))
+                    )
+           (set! (-> self last-attack-id) (-> (the-as attack-info v1-1) id))
+           (send-event self 'bomb-hit (target-pos 0) 4)
+           (let ((gp-2 (get-process *default-dead-pool* part-tracker #x4000)))
+             (when gp-2
+               (let ((t9-3 (method-of-type part-tracker activate)))
+                 (t9-3
+                   (the-as part-tracker gp-2)
+                   *entity-pool*
+                   (symbol->string (-> part-tracker symbol))
+                   (the-as pointer #x70004000)
+                   )
+                 )
+               (let ((s5-0 run-function-in-process)
+                     (s4-0 gp-2)
+                     (s3-0 part-tracker-init)
+                     (s2-0 (-> *part-group-id-table* 710))
+                     (s1-0 600)
+                     (s0-0 #f)
+                     )
+                 (set! sv-224 (the-as symbol #f))
+                 (set! sv-240 (the-as symbol #f))
+                 (set! sv-272 *launch-matrix*)
+                 (set! sv-256 (-> sv-272 trans))
+                 (let ((v1-16 (-> (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 11)) quad)))
+                   (set! (-> sv-256 quad) v1-16)
+                   )
+                 ((the-as (function object object object object object object object object none) s5-0)
+                  s4-0
+                  s3-0
+                  s2-0
+                  s1-0
+                  s0-0
+                  sv-224
+                  sv-240
+                  sv-272
+                  )
+                 )
+               (-> gp-2 ppointer)
+               )
+             )
+           )
+         )
+       )
+      (('shot-hit-target)
+       (when (< (-> self last-gun-hit-stage) (-> self current-shoot-stage))
+         (+! (-> self gun-hits) 1)
+         (set! v0-0 (-> self current-shoot-stage))
+         (set! (-> self last-gun-hit-stage) (the-as int v0-0))
+         v0-0
+         )
+       )
+      (('bomb-kicked)
+       (set! v0-0 (+ (-> self kicked-bombs) 1))
+       (set! (-> self kicked-bombs) (the-as int v0-0))
+       v0-0
+       )
+      (('widow-get-center)
+       (-> self circle-center)
+       )
+      (('debris-hit)
+       (when (< -819.2 (-> self osc vel y))
+         (sound-play "wid-debris-hit")
+         (case (-> arg3 param 0)
+           ((1)
+            (set! (-> self osc vel y) (+ -3072.0 (-> self osc vel y)))
+            )
+           ((2)
+            (set! (-> self osc vel y) (+ -2048.0 (-> self osc vel y)))
+            )
+           )
+         )
+       )
+      (('catwalk-hit)
+       (let ((v1-26 (-> arg3 param 0)))
+         (when (and (> (the-as int v1-26) 0) (< (the-as int v1-26) 8))
+           (let ((v1-28 (new 'stack-no-clear 'event-message-block)))
+             (set! (-> v1-28 from) (process->ppointer arg0))
+             (set! (-> v1-28 num-params) arg1)
+             (set! (-> v1-28 message) arg2)
+             (set! (-> v1-28 param 0) (-> arg3 param 0))
+             (set! (-> v1-28 param 1) (-> arg3 param 1))
+             (set! (-> v1-28 param 2) (-> arg3 param 2))
+             (set! (-> v1-28 param 3) (-> arg3 param 3))
+             (set! (-> v1-28 param 4) (-> arg3 param 4))
+             (set! (-> v1-28 param 5) (-> arg3 param 5))
+             (send-event-function (handle->process (-> self catwalk 0)) v1-28)
+             )
+           )
+         )
+       )
+      (('child-jumped)
+       (set! v0-0 (logclear (-> (the-as spydroid arg0) enemy-flags) (enemy-flag alert)))
+       (set! (-> (the-as spydroid arg0) enemy-flags) (the-as enemy-flag v0-0))
+       v0-0
+       )
+      (('bomb-hit)
+       (set! (-> self bomb-hits) (min 4 (+ (-> self bomb-hits) (-> arg3 param 1))))
+       (let ((v1-33 (handle->process (-> self hud))))
+         (if v1-33
+             (set! (-> (the-as hud-widow v1-33) values 1 target) (/ (* 100 (- 4 (-> self bomb-hits))) 4))
+             )
+         )
+       (when (and (not (-> self flying)) (< (-> self bomb-hits) 4))
+         (let* ((s4-2 (-> arg3 param 0))
+                (v0-9 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 3)))
+                (s5-2 (-> self node-list data 3 bone transform))
+                (s4-3 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) (the-as vector s4-2) v0-9) 1.0))
+                (f30-0 (vector-dot s4-3 (vector-normalize-copy! (new 'stack-no-clear 'vector) (-> s5-2 vector 2) 1.0)))
+                (f28-0
+                  (vector-dot s4-3 (vector-normalize-copy! (new 'stack-no-clear 'vector) (the-as vector (-> s5-2 vector)) 1.0))
+                  )
+                )
+           (ja-channel-push! 1 (seconds 0.03))
+           (set! (-> self drill-speed target) 0.0)
+           (cond
+             ((< (cos 5461.3335) f30-0)
+              (ja :group! (-> self draw art-group data 25) :num! min)
+              (setup-masks (-> self draw) 2 128)
+              )
+             ((and (< (cos 8192.0) f30-0) (< 0.0 f28-0))
+              (ja :group! (-> self draw art-group data 26) :num! min)
+              (setup-masks (-> self draw) 4 256)
+              )
+             ((< (cos 8192.0) f30-0)
+              (ja :group! (-> self draw art-group data 27) :num! min)
+              (setup-masks (-> self draw) 8 512)
+              )
+             ((< 0.0 f28-0)
+              (ja :group! (-> self draw art-group data 23) :num! min)
+              (setup-masks (-> self draw) 16 1024)
+              )
+             (else
+               (ja :group! (-> self draw art-group data 24) :num! min)
+               (setup-masks (-> self draw) 32 2048)
+               )
+             )
+           )
+         )
+       (when (-> self flying)
+         (set! (-> self drill-speed target) 0.0)
+         (cond
+           ((>= (-> self bomb-hits) 4)
+            #f
+            )
+           ((begin
+              (ja-channel-push! 1 (seconds 0.03))
+              (let* ((gp-3 (-> arg3 param 0))
+                     (v0-28 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 3)))
+                     (s5-8 (-> self node-list data 3 bone transform))
+                     (f0-20 (vector-dot
+                              (vector-normalize! (vector-! (new 'stack-no-clear 'vector) (the-as vector gp-3) v0-28) 1.0)
+                              (vector-normalize-copy! (new 'stack-no-clear 'vector) (the-as vector (-> s5-8 vector)) 1.0)
+                              )
+                            )
+                     )
+                (< 0.0 f0-20)
+                )
+              )
+            (ja :group! (-> self draw art-group data 37) :num! min)
+            (the-as object (setup-masks (-> self draw) 16 1024))
+            )
+           (else
+             (ja :group! (-> self draw art-group data 36) :num! min)
+             (the-as object (setup-masks (-> self draw) 32 2048))
+             )
+           )
+         )
+       )
+      )
+    )
+  )
diff --git a/test/decompiler/reference/jak2/levels/mars_tomb/widow-extras_REF.gc b/test/decompiler/reference/jak2/levels/mars_tomb/widow-extras_REF.gc
new file mode 100644
index 0000000000..351ea0a40e
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/mars_tomb/widow-extras_REF.gc
@@ -0,0 +1,2147 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type tomb-boss-catwalk
+(deftype tomb-boss-catwalk (process-drawable)
+  ((root-override collide-shape-moving  :offset        128)
+   (which-look    int32                 :offset-assert 200)
+   )
+  :heap-base #x50
+  :method-count-assert 23
+  :size-assert         #xcc
+  :flag-assert         #x17005000cc
+  (:methods
+    (shatter () _type_ :state 20)
+    (idle () _type_ :state 21)
+    (tomb-boss-catwalk-method-22 (_type_ vector int) none 22)
+    )
+  )
+
+;; definition for method 3 of type tomb-boss-catwalk
+(defmethod inspect tomb-boss-catwalk ((obj tomb-boss-catwalk))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Twhich-look: ~D~%" (-> obj which-look))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-tomb-boss-catwalk-main tomb-boss-catwalk tomb-boss-catwalk-main-lod0-jg tomb-boss-catwalk-main-idle-ja
+              ((tomb-boss-catwalk-main-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 80)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-tomb-boss-catwalk-a tomb-boss-catwalk tomb-boss-catwalk-a-lod0-jg tomb-boss-catwalk-a-idle-ja
+              ((tomb-boss-catwalk-a-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -2 0 18)
+              :origin-joint-index 30
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-tomb-boss-catwalk-b tomb-boss-catwalk tomb-boss-catwalk-b-lod0-jg tomb-boss-catwalk-b-idle-ja
+              ((tomb-boss-catwalk-b-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -2 0 14)
+              :origin-joint-index 30
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-tomb-boss-catwalk-c tomb-boss-catwalk tomb-boss-catwalk-c-lod0-jg tomb-boss-catwalk-c-idle-ja
+              ((tomb-boss-catwalk-c-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -2 0 14)
+              :origin-joint-index 30
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-tomb-boss-catwalk-d tomb-boss-catwalk tomb-boss-catwalk-d-lod0-jg tomb-boss-catwalk-d-idle-ja
+              ((tomb-boss-catwalk-d-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -2 0 14)
+              :origin-joint-index 30
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-tomb-boss-catwalk-e tomb-boss-catwalk tomb-boss-catwalk-e-lod0-jg tomb-boss-catwalk-e-idle-ja
+              ((tomb-boss-catwalk-e-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -2 0 14)
+              :origin-joint-index 18
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-tomb-boss-catwalk-f tomb-boss-catwalk tomb-boss-catwalk-f-lod0-jg tomb-boss-catwalk-f-idle-ja
+              ((tomb-boss-catwalk-f-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -2 0 14)
+              :origin-joint-index 30
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-tomb-boss-catwalk-g tomb-boss-catwalk tomb-boss-catwalk-g-lod0-jg tomb-boss-catwalk-g-idle-ja
+              ((tomb-boss-catwalk-g-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -2 0 14)
+              :origin-joint-index 30
+              )
+
+;; failed to figure out what this is:
+(defstate shatter (tomb-boss-catwalk)
+  :virtual #t
+  :enter (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
+    (logclear! (-> self draw status) (draw-control-status no-draw-bounds))
+    (set! (-> self draw bounds w) 245760.0)
+    (let ((gp-0 (new 'stack-no-clear 'vector)))
+      (case (-> self which-look)
+        ((1)
+         (ja :group! (-> self draw art-group data 3) :num! min)
+         (set-vector! gp-0 188416.0 32768.0 -81920.0 1.0)
+         )
+        ((2)
+         (ja :group! (-> self draw art-group data 8) :num! min)
+         (set-vector! gp-0 139264.0 32768.0 -147456.0 1.0)
+         )
+        ((3)
+         (ja :group! (-> self draw art-group data 13) :num! min)
+         (set-vector! gp-0 81920.0 32768.0 -188416.0 1.0)
+         )
+        ((4)
+         (ja :group! (-> self draw art-group data 18) :num! min)
+         (set-vector! gp-0 0.0 32768.0 -200704.0 1.0)
+         )
+        ((5)
+         (ja :group! (-> self draw art-group data 23) :num! min)
+         (set-vector! gp-0 -81920.0 32768.0 -188416.0 1.0)
+         )
+        ((6)
+         (ja :group! (-> self draw art-group data 28) :num! min)
+         (set-vector! gp-0 -139264.0 32768.0 -147456.0 1.0)
+         )
+        ((7)
+         (ja :group! (-> self draw art-group data 33) :num! min)
+         (set-vector! gp-0 -188416.0 32768.0 -81920.0 1.0)
+         )
+        )
+      (vector+! gp-0 gp-0 (-> self root-override trans))
+      (let ((s5-7 (get-process *default-dead-pool* part-tracker #x4000)))
+        (when s5-7
+          (let ((t9-8 (method-of-type part-tracker activate)))
+            (t9-8
+              (the-as part-tracker s5-7)
+              *entity-pool*
+              (symbol->string (-> part-tracker symbol))
+              (the-as pointer #x70004000)
+              )
+            )
+          (let ((t9-9 run-function-in-process)
+                (a0-54 s5-7)
+                (a1-11 part-tracker-init)
+                (a2-11 (-> *part-group-id-table* 717))
+                (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-9)
+             a0-54
+             a1-11
+             a2-11
+             a3-1
+             t0-0
+             t1-0
+             t2-0
+             t3-0
+             )
+            )
+          (-> s5-7 ppointer)
+          )
+        )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    (ja :num! (seek!))
+    (if (ja-done? 0)
+        (deactivate self)
+        )
+    (none)
+    )
+  :code (the-as (function none :behavior tomb-boss-catwalk) sleep-code)
+  :post (the-as (function none :behavior tomb-boss-catwalk) ja-post)
+  )
+
+;; failed to figure out what this is:
+(defstate idle (tomb-boss-catwalk)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as object (case event-type
+                     (('catwalk-hit)
+                      (when (zero? (-> self which-look))
+                        (case (-> event param 0)
+                          ((1)
+                           (the-as object (setup-masks (-> self draw) 0 1))
+                           )
+                          ((2)
+                           (the-as object (setup-masks (-> self draw) 0 2))
+                           )
+                          ((3)
+                           (the-as object (setup-masks (-> self draw) 0 4))
+                           )
+                          ((4)
+                           (the-as object (setup-masks (-> self draw) 0 8))
+                           )
+                          ((5)
+                           (the-as object (setup-masks (-> self draw) 0 16))
+                           )
+                          ((6)
+                           (the-as object (setup-masks (-> self draw) 0 32))
+                           )
+                          ((7)
+                           (the-as object (setup-masks (-> self draw) 0 64))
+                           )
+                          )
+                        )
+                      )
+                     (('green-hit)
+                      (when (nonzero? (-> self which-look))
+                        (send-event (ppointer->process (-> self parent)) 'catwalk-hit (-> self which-look))
+                        (go-virtual shatter)
+                        )
+                      )
+                     )
+            )
+    )
+  :code (the-as (function none :behavior tomb-boss-catwalk) sleep-code)
+  )
+
+;; definition for method 22 of type tomb-boss-catwalk
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod tomb-boss-catwalk-method-22 tomb-boss-catwalk ((obj tomb-boss-catwalk) (arg0 vector) (arg1 int))
+  (case arg1
+    ((1)
+     (let ((s3-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+       (let ((v1-3 (new 'process 'collide-shape-prim-mesh s3-0 (the-as uint 0) (the-as uint 0))))
+         (set! (-> v1-3 prim-core collide-as) (collide-spec obstacle))
+         (set! (-> v1-3 prim-core collide-with) (collide-spec jak bot player-list))
+         (set! (-> v1-3 prim-core action) (collide-action solid))
+         (set! (-> v1-3 transform-index) 30)
+         (set-vector! (-> v1-3 local-sphere) 0.0 -12288.0 0.0 57344.0)
+         (set! (-> s3-0 total-prims) (the-as uint 1))
+         (set! (-> s3-0 root-prim) v1-3)
+         )
+       (set! (-> s3-0 nav-radius) 8192.0)
+       (let ((v1-5 (-> s3-0 root-prim)))
+         (set! (-> s3-0 backup-collide-as) (-> v1-5 prim-core collide-as))
+         (set! (-> s3-0 backup-collide-with) (-> v1-5 prim-core collide-with))
+         )
+       (set! (-> obj root-override) (the-as collide-shape-moving s3-0))
+       )
+     )
+    ((2)
+     (let ((s3-1 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+       (let ((v1-9 (new 'process 'collide-shape-prim-mesh s3-1 (the-as uint 0) (the-as uint 0))))
+         (set! (-> v1-9 prim-core collide-as) (collide-spec obstacle))
+         (set! (-> v1-9 prim-core collide-with) (collide-spec jak bot player-list))
+         (set! (-> v1-9 prim-core action) (collide-action solid))
+         (set! (-> v1-9 transform-index) 30)
+         (set-vector! (-> v1-9 local-sphere) 0.0 0.0 0.0 65536.0)
+         (set! (-> s3-1 total-prims) (the-as uint 1))
+         (set! (-> s3-1 root-prim) v1-9)
+         )
+       (set! (-> s3-1 nav-radius) 8192.0)
+       (let ((v1-11 (-> s3-1 root-prim)))
+         (set! (-> s3-1 backup-collide-as) (-> v1-11 prim-core collide-as))
+         (set! (-> s3-1 backup-collide-with) (-> v1-11 prim-core collide-with))
+         )
+       (set! (-> obj root-override) (the-as collide-shape-moving s3-1))
+       )
+     )
+    ((3)
+     (let ((s3-2 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+       (let ((v1-15 (new 'process 'collide-shape-prim-mesh s3-2 (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 player-list))
+         (set! (-> v1-15 prim-core action) (collide-action solid))
+         (set! (-> v1-15 transform-index) 30)
+         (set-vector! (-> v1-15 local-sphere) 0.0 0.0 0.0 65536.0)
+         (set! (-> s3-2 total-prims) (the-as uint 1))
+         (set! (-> s3-2 root-prim) v1-15)
+         )
+       (set! (-> s3-2 nav-radius) 8192.0)
+       (let ((v1-17 (-> s3-2 root-prim)))
+         (set! (-> s3-2 backup-collide-as) (-> v1-17 prim-core collide-as))
+         (set! (-> s3-2 backup-collide-with) (-> v1-17 prim-core collide-with))
+         )
+       (set! (-> obj root-override) (the-as collide-shape-moving s3-2))
+       )
+     )
+    ((4)
+     (let ((s3-3 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+       (let ((v1-21 (new 'process 'collide-shape-prim-mesh s3-3 (the-as uint 0) (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 player-list))
+         (set! (-> v1-21 prim-core action) (collide-action solid))
+         (set! (-> v1-21 transform-index) 30)
+         (set-vector! (-> v1-21 local-sphere) 0.0 0.0 0.0 65536.0)
+         (set! (-> s3-3 total-prims) (the-as uint 1))
+         (set! (-> s3-3 root-prim) v1-21)
+         )
+       (set! (-> s3-3 nav-radius) 8192.0)
+       (let ((v1-23 (-> s3-3 root-prim)))
+         (set! (-> s3-3 backup-collide-as) (-> v1-23 prim-core collide-as))
+         (set! (-> s3-3 backup-collide-with) (-> v1-23 prim-core collide-with))
+         )
+       (set! (-> obj root-override) (the-as collide-shape-moving s3-3))
+       )
+     )
+    ((5)
+     (let ((s3-4 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+       (let ((v1-27 (new 'process 'collide-shape-prim-mesh s3-4 (the-as uint 0) (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 player-list))
+         (set! (-> v1-27 prim-core action) (collide-action solid))
+         (set! (-> v1-27 transform-index) 18)
+         (set-vector! (-> v1-27 local-sphere) 0.0 0.0 0.0 65536.0)
+         (set! (-> s3-4 total-prims) (the-as uint 1))
+         (set! (-> s3-4 root-prim) v1-27)
+         )
+       (set! (-> s3-4 nav-radius) 8192.0)
+       (let ((v1-29 (-> s3-4 root-prim)))
+         (set! (-> s3-4 backup-collide-as) (-> v1-29 prim-core collide-as))
+         (set! (-> s3-4 backup-collide-with) (-> v1-29 prim-core collide-with))
+         )
+       (set! (-> obj root-override) (the-as collide-shape-moving s3-4))
+       )
+     )
+    ((6)
+     (let ((s3-5 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+       (let ((v1-33 (new 'process 'collide-shape-prim-mesh s3-5 (the-as uint 0) (the-as uint 0))))
+         (set! (-> v1-33 prim-core collide-as) (collide-spec obstacle))
+         (set! (-> v1-33 prim-core collide-with) (collide-spec jak bot player-list))
+         (set! (-> v1-33 prim-core action) (collide-action solid))
+         (set! (-> v1-33 transform-index) 30)
+         (set-vector! (-> v1-33 local-sphere) 0.0 0.0 0.0 65536.0)
+         (set! (-> s3-5 total-prims) (the-as uint 1))
+         (set! (-> s3-5 root-prim) v1-33)
+         )
+       (set! (-> s3-5 nav-radius) 8192.0)
+       (let ((v1-35 (-> s3-5 root-prim)))
+         (set! (-> s3-5 backup-collide-as) (-> v1-35 prim-core collide-as))
+         (set! (-> s3-5 backup-collide-with) (-> v1-35 prim-core collide-with))
+         )
+       (set! (-> obj root-override) (the-as collide-shape-moving s3-5))
+       )
+     )
+    ((7)
+     (let ((s3-6 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+       (let ((v1-39 (new 'process 'collide-shape-prim-mesh s3-6 (the-as uint 0) (the-as uint 0))))
+         (set! (-> v1-39 prim-core collide-as) (collide-spec obstacle))
+         (set! (-> v1-39 prim-core collide-with) (collide-spec jak bot player-list))
+         (set! (-> v1-39 prim-core action) (collide-action solid))
+         (set! (-> v1-39 transform-index) 30)
+         (set-vector! (-> v1-39 local-sphere) 0.0 0.0 0.0 65536.0)
+         (set! (-> s3-6 total-prims) (the-as uint 1))
+         (set! (-> s3-6 root-prim) v1-39)
+         )
+       (set! (-> s3-6 nav-radius) 8192.0)
+       (let ((v1-41 (-> s3-6 root-prim)))
+         (set! (-> s3-6 backup-collide-as) (-> v1-41 prim-core collide-as))
+         (set! (-> s3-6 backup-collide-with) (-> v1-41 prim-core collide-with))
+         )
+       (set! (-> obj root-override) (the-as collide-shape-moving s3-6))
+       )
+     )
+    (else
+      (let ((s3-7 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+        (let ((s2-0 (new 'process 'collide-shape-prim-group s3-7 (the-as uint 8) 0)))
+          (set! (-> s3-7 total-prims) (the-as uint 9))
+          (set! (-> s2-0 prim-core collide-as) (collide-spec obstacle))
+          (set! (-> s2-0 prim-core collide-with) (collide-spec jak player-list))
+          (set! (-> s2-0 prim-core action) (collide-action solid))
+          (set! (-> s2-0 transform-index) 3)
+          (set-vector! (-> s2-0 local-sphere) 0.0 0.0 0.0 327680.0)
+          (set! (-> s3-7 root-prim) s2-0)
+          )
+        (let ((v1-52 (new 'process 'collide-shape-prim-mesh s3-7 (the-as uint 7) (the-as uint 0))))
+          (set! (-> v1-52 prim-core collide-as) (collide-spec obstacle))
+          (set! (-> v1-52 prim-core collide-with) (collide-spec jak bot player-list))
+          (set! (-> v1-52 prim-core action) (collide-action solid))
+          (set! (-> v1-52 transform-index) 11)
+          (set-vector! (-> v1-52 local-sphere) 0.0 114688.0 0.0 65536.0)
+          )
+        (let ((v1-54 (new 'process 'collide-shape-prim-mesh s3-7 (the-as uint 6) (the-as uint 0))))
+          (set! (-> v1-54 prim-core collide-as) (collide-spec obstacle))
+          (set! (-> v1-54 prim-core collide-with) (collide-spec jak bot player-list))
+          (set! (-> v1-54 prim-core action) (collide-action solid))
+          (set! (-> v1-54 transform-index) 10)
+          (set-vector! (-> v1-54 local-sphere) 0.0 114688.0 0.0 65536.0)
+          )
+        (let ((v1-56 (new 'process 'collide-shape-prim-mesh s3-7 (the-as uint 5) (the-as uint 0))))
+          (set! (-> v1-56 prim-core collide-as) (collide-spec obstacle))
+          (set! (-> v1-56 prim-core collide-with) (collide-spec jak bot player-list))
+          (set! (-> v1-56 prim-core action) (collide-action solid))
+          (set! (-> v1-56 transform-index) 9)
+          (set-vector! (-> v1-56 local-sphere) 0.0 114688.0 0.0 57344.0)
+          )
+        (let ((v1-58 (new 'process 'collide-shape-prim-mesh s3-7 (the-as uint 4) (the-as uint 0))))
+          (set! (-> v1-58 prim-core collide-as) (collide-spec obstacle))
+          (set! (-> v1-58 prim-core collide-with) (collide-spec jak bot player-list))
+          (set! (-> v1-58 prim-core action) (collide-action solid))
+          (set! (-> v1-58 transform-index) 8)
+          (set-vector! (-> v1-58 local-sphere) 0.0 114688.0 0.0 61440.0)
+          )
+        (let ((v1-60 (new 'process 'collide-shape-prim-mesh s3-7 (the-as uint 3) (the-as uint 0))))
+          (set! (-> v1-60 prim-core collide-as) (collide-spec obstacle))
+          (set! (-> v1-60 prim-core collide-with) (collide-spec jak bot player-list))
+          (set! (-> v1-60 prim-core action) (collide-action solid))
+          (set! (-> v1-60 transform-index) 7)
+          (set-vector! (-> v1-60 local-sphere) 0.0 114688.0 0.0 61440.0)
+          )
+        (let ((v1-62 (new 'process 'collide-shape-prim-mesh s3-7 (the-as uint 2) (the-as uint 0))))
+          (set! (-> v1-62 prim-core collide-as) (collide-spec obstacle))
+          (set! (-> v1-62 prim-core collide-with) (collide-spec jak bot player-list))
+          (set! (-> v1-62 prim-core action) (collide-action solid))
+          (set! (-> v1-62 transform-index) 6)
+          (set-vector! (-> v1-62 local-sphere) -8192.0 114688.0 0.0 57344.0)
+          )
+        (let ((v1-64 (new 'process 'collide-shape-prim-mesh s3-7 (the-as uint 1) (the-as uint 0))))
+          (set! (-> v1-64 prim-core collide-as) (collide-spec obstacle))
+          (set! (-> v1-64 prim-core collide-with) (collide-spec jak bot player-list))
+          (set! (-> v1-64 prim-core action) (collide-action solid))
+          (set! (-> v1-64 transform-index) 5)
+          (set-vector! (-> v1-64 local-sphere) -4096.0 114688.0 0.0 57344.0)
+          )
+        (let ((v1-66 (new 'process 'collide-shape-prim-mesh s3-7 (the-as uint 0) (the-as uint 0))))
+          (set! (-> v1-66 prim-core collide-as) (collide-spec obstacle))
+          (set! (-> v1-66 prim-core collide-with) (collide-spec jak bot player-list))
+          (set! (-> v1-66 prim-core action) (collide-action solid))
+          (set! (-> v1-66 transform-index) 4)
+          (set-vector! (-> v1-66 local-sphere) 0.0 114688.0 0.0 65536.0)
+          )
+        (set! (-> s3-7 nav-radius) 8192.0)
+        (let ((v1-68 (-> s3-7 root-prim)))
+          (set! (-> s3-7 backup-collide-as) (-> v1-68 prim-core collide-as))
+          (set! (-> s3-7 backup-collide-with) (-> v1-68 prim-core collide-with))
+          )
+        (set! (-> obj root-override) (the-as collide-shape-moving s3-7))
+        )
+      )
+    )
+  (set! (-> obj root-override trans quad) (-> arg0 quad))
+  (case arg1
+    ((1)
+     (initialize-skeleton
+       obj
+       (the-as
+         skeleton-group
+         (art-group-get-by-name *level* "skel-tomb-boss-catwalk-a" (the-as (pointer uint32) #f))
+         )
+       (the-as pair 0)
+       )
+     (logior! (-> obj draw status) (draw-control-status no-draw-bounds))
+     )
+    ((2)
+     (initialize-skeleton
+       obj
+       (the-as
+         skeleton-group
+         (art-group-get-by-name *level* "skel-tomb-boss-catwalk-b" (the-as (pointer uint32) #f))
+         )
+       (the-as pair 0)
+       )
+     (logior! (-> obj draw status) (draw-control-status no-draw-bounds))
+     )
+    ((3)
+     (initialize-skeleton
+       obj
+       (the-as
+         skeleton-group
+         (art-group-get-by-name *level* "skel-tomb-boss-catwalk-c" (the-as (pointer uint32) #f))
+         )
+       (the-as pair 0)
+       )
+     (logior! (-> obj draw status) (draw-control-status no-draw-bounds))
+     )
+    ((4)
+     (initialize-skeleton
+       obj
+       (the-as
+         skeleton-group
+         (art-group-get-by-name *level* "skel-tomb-boss-catwalk-d" (the-as (pointer uint32) #f))
+         )
+       (the-as pair 0)
+       )
+     (logior! (-> obj draw status) (draw-control-status no-draw-bounds))
+     )
+    ((5)
+     (initialize-skeleton
+       obj
+       (the-as
+         skeleton-group
+         (art-group-get-by-name *level* "skel-tomb-boss-catwalk-e" (the-as (pointer uint32) #f))
+         )
+       (the-as pair 0)
+       )
+     (logior! (-> obj draw status) (draw-control-status no-draw-bounds))
+     )
+    ((6)
+     (initialize-skeleton
+       obj
+       (the-as
+         skeleton-group
+         (art-group-get-by-name *level* "skel-tomb-boss-catwalk-f" (the-as (pointer uint32) #f))
+         )
+       (the-as pair 0)
+       )
+     (logior! (-> obj draw status) (draw-control-status no-draw-bounds))
+     )
+    ((7)
+     (initialize-skeleton
+       obj
+       (the-as
+         skeleton-group
+         (art-group-get-by-name *level* "skel-tomb-boss-catwalk-g" (the-as (pointer uint32) #f))
+         )
+       (the-as pair 0)
+       )
+     (logior! (-> obj draw status) (draw-control-status no-draw-bounds))
+     )
+    (else
+      (initialize-skeleton
+        obj
+        (the-as
+          skeleton-group
+          (art-group-get-by-name *level* "skel-tomb-boss-catwalk-main" (the-as (pointer uint32) #f))
+          )
+        (the-as pair 0)
+        )
+      )
+    )
+  (set! (-> obj root-override pause-adjust-distance) 245760.0)
+  (set! (-> obj which-look) arg1)
+  (quaternion-set! (-> obj root-override quat) 0.0 1.0 0.0 0.0)
+  (transform-post)
+  0
+  (none)
+  )
+
+;; definition for method 11 of type tomb-boss-catwalk
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! tomb-boss-catwalk ((obj tomb-boss-catwalk) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (let ((a2-1 (res-lump-value arg0 'mode uint128 :time -1000000000.0)))
+    (tomb-boss-catwalk-method-22 obj (-> arg0 extra trans) (the-as int a2-1))
+    )
+  (cleanup-for-death obj)
+  (deactivate obj)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition for function tomb-boss-catwalk-init-by-other
+;; WARN: Return type mismatch object vs none.
+(defbehavior tomb-boss-catwalk-init-by-other tomb-boss-catwalk ((arg0 vector) (arg1 int))
+  (tomb-boss-catwalk-method-22 self arg0 arg1)
+  (set! (-> self event-hook) (-> (method-of-object self idle) event))
+  (set! (-> self draw light-index) (the-as uint 2))
+  (go-virtual idle)
+  (none)
+  )
+
+;; definition of type tomb-boss-catwalk-main
+(deftype tomb-boss-catwalk-main (tomb-boss-catwalk)
+  ()
+  :heap-base #x50
+  :method-count-assert 23
+  :size-assert         #xcc
+  :flag-assert         #x17005000cc
+  )
+
+;; definition for method 3 of type tomb-boss-catwalk-main
+(defmethod inspect tomb-boss-catwalk-main ((obj tomb-boss-catwalk-main))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type tomb-boss-catwalk inspect)))
+    (t9-0 obj)
+    )
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type widow-bomb
+(deftype widow-bomb (process-focusable)
+  ((traj                  trajectory               :inline :offset-assert 208)
+   (explode-part          sparticle-launch-control         :offset-assert 248)
+   (trail-part            sparticle-launch-control         :offset-assert 252)
+   (warning-glow-part     sparticle-launch-control         :offset-assert 256)
+   (warning-spark-part    sparticle-launch-control         :offset-assert 260)
+   (impact                impact-control           :inline :offset-assert 272)
+   (which-trajectory      int32                            :offset-assert 352)
+   (next-countdown-tick   time-frame                       :offset-assert 360)
+   (skid-part             sparticle-launch-control         :offset-assert 368)
+   (x-rotate              float                            :offset-assert 372)
+   (y-rotate              float                            :offset-assert 376)
+   (spin-jm               joint-mod                        :offset-assert 380)
+   (firework-sound-played symbol                           :offset-assert 384)
+   (steam-sound           uint32                           :offset-assert 388)
+   (launch                vector                   :inline :offset-assert 400)
+   (launch-pos            vector                   :inline :offset-assert 416)
+   (fizzle-timer          time-frame                       :offset-assert 432)
+   )
+  :heap-base #x140
+  :method-count-assert 35
+  :size-assert         #x1b8
+  :flag-assert         #x23014001b8
+  (:methods
+    (freefall () _type_ :state 27)
+    (back-atcha () _type_ :state 28)
+    (explode () _type_ :state 29)
+    (smoke () _type_ :state 30)
+    (idle () _type_ :state 31)
+    (widow-bomb-method-32 (_type_) none 32)
+    (widow-bomb-method-33 (_type_) none 33)
+    (widow-bomb-method-34 (_type_) none 34)
+    )
+  )
+
+;; definition for method 3 of type widow-bomb
+(defmethod inspect widow-bomb ((obj widow-bomb))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-focusable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Ttraj: #<trajectory @ #x~X>~%" (-> obj traj))
+  (format #t "~2Texplode-part: ~A~%" (-> obj explode-part))
+  (format #t "~2Ttrail-part: ~A~%" (-> obj trail-part))
+  (format #t "~2Twarning-glow-part: ~A~%" (-> obj warning-glow-part))
+  (format #t "~2Twarning-spark-part: ~A~%" (-> obj warning-spark-part))
+  (format #t "~2Timpact: #<impact-control @ #x~X>~%" (-> obj impact))
+  (format #t "~2Twhich-trajectory: ~D~%" (-> obj which-trajectory))
+  (format #t "~2Tnext-countdown-tick: ~D~%" (-> obj next-countdown-tick))
+  (format #t "~2Tskid-part: ~A~%" (-> obj skid-part))
+  (format #t "~2Tx-rotate: ~f~%" (-> obj x-rotate))
+  (format #t "~2Ty-rotate: ~f~%" (-> obj y-rotate))
+  (format #t "~2Tspin-jm: ~A~%" (-> obj spin-jm))
+  (format #t "~2Tfirework-sound-played: ~A~%" (-> obj firework-sound-played))
+  (format #t "~2Tsteam-sound: ~D~%" (-> obj steam-sound))
+  (format #t "~2Tlaunch: #<vector @ #x~X>~%" (-> obj launch))
+  (format #t "~2Tlaunch-pos: #<vector @ #x~X>~%" (-> obj launch-pos))
+  (format #t "~2Tfizzle-timer: ~D~%" (-> obj fizzle-timer))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-widow-bomb widow-bomb widow-bomb-lod0-jg widow-bomb-idle-ja
+              ((widow-bomb-lod0-mg (meters 20)) (widow-bomb-lod1-mg (meters 40)) (widow-bomb-lod2-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+;; definition for method 34 of type widow-bomb
+;; INFO: Used lq/sq
+;; ERROR: Stack slot load at 48 mismatch: defined as size 4, got size 16
+;; ERROR: Stack slot load at 64 mismatch: defined as size 4, got size 16
+;; ERROR: Stack slot load at 48 mismatch: defined as size 4, got size 16
+;; ERROR: Stack slot load at 64 mismatch: defined as size 4, got size 16
+;; ERROR: Stack slot load at 48 mismatch: defined as size 4, got size 16
+;; ERROR: Stack slot load at 64 mismatch: defined as size 4, got size 16
+;; WARN: Return type mismatch int vs none.
+(defmethod widow-bomb-method-34 widow-bomb ((obj widow-bomb))
+  (local-vars (sv-48 float) (sv-64 float))
+  (let ((s5-0 (new 'stack-no-clear 'quaternion))
+        (gp-0 (new 'stack-no-clear 'quaternion))
+        )
+    (let ((s3-0 quaternion-set!)
+          (s2-0 s5-0)
+          (s1-0 (sin (* 0.5 (-> obj x-rotate))))
+          (s0-0 0.0)
+          )
+      (set! sv-48 (the-as float 0.0))
+      (let ((t0-0 (cos (* 0.5 (-> obj x-rotate)))))
+        (s3-0 s2-0 s1-0 s0-0 sv-48 t0-0)
+        )
+      )
+    (let ((s3-1 quaternion-set!)
+          (s2-1 gp-0)
+          (s1-1 0.0)
+          (s0-1 (sin (* 0.5 (-> obj y-rotate))))
+          )
+      (set! sv-64 (the-as float 0.0))
+      (let ((t0-1 (cos (* 0.5 (-> obj y-rotate)))))
+        (s3-1 s2-1 s1-1 s0-1 sv-64 t0-1)
+        )
+      )
+    (quaternion-normalize! (quaternion*! (-> obj spin-jm quat) gp-0 s5-0))
+    )
+  0
+  (none)
+  )
+
+;; definition for function widow-bomb-handler
+;; WARN: Return type mismatch object vs none.
+(defbehavior widow-bomb-handler widow-bomb ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (local-vars (v1-13 float))
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf1 :class vf)
+         (vf2 :class vf)
+         )
+    (init-vf0-vector)
+    (case arg2
+      (('attack)
+       (cond
+         ((= (-> arg0 type) target)
+          (let ((gp-0 (new 'stack-no-clear 'vector))
+                (f30-0 32768.0)
+                )
+            (let* ((s4-0 (ppointer->process (-> self parent)))
+                   (v1-5 (if (type? s4-0 widow)
+                             (the-as widow s4-0)
+                             )
+                         )
+                   )
+              (vector-! gp-0 (-> self root-override trans) (-> (the-as widow arg0) root trans))
+              (set! (-> gp-0 y) 0.0)
+              (cond
+                (v1-5
+                  (if (-> v1-5 flying)
+                      (set! f30-0 16384.0)
+                      )
+                  (let ((s4-1 (vector<-cspace! (new 'stack-no-clear 'vector) (-> v1-5 node-list data 3)))
+                        (s5-1 (new 'stack-no-clear 'vector))
+                        )
+                    (let ((f28-0 20480.0))
+                      (vector-! s4-1 s4-1 (-> self root-override trans))
+                      (let ((t9-2 vector-normalize!)
+                            (a0-14 gp-0)
+                            (v1-9 s4-1)
+                            )
+                        (t9-2 a0-14 (sqrtf (+ (* (-> v1-9 x) (-> v1-9 x)) (* (-> v1-9 z) (-> v1-9 z)))))
+                        )
+                      (set! (-> gp-0 y) (-> s4-1 y))
+                      (vector-! s5-1 s4-1 gp-0)
+                      (let* ((f0-6 f28-0)
+                             (f0-8 (* f0-6 f0-6))
+                             )
+                        (.lvf vf1 (&-> s5-1 quad))
+                        (.add.w.vf vf2 vf0 vf0 :mask #b1)
+                        (.mul.vf vf1 vf1 vf1)
+                        (.mul.x.vf acc vf2 vf1 :mask #b1)
+                        (.add.mul.y.vf acc vf2 vf1 acc :mask #b1)
+                        (.add.mul.z.vf vf1 vf2 vf1 acc :mask #b1)
+                        (.mov v1-13 vf1)
+                        (if (< f0-8 v1-13)
+                            (vector-normalize! s5-1 f28-0)
+                            )
+                        )
+                      )
+                    (vector+! gp-0 gp-0 s5-1)
+                    )
+                  )
+                (else
+                  (vector-normalize! gp-0 200704.0)
+                  )
+                )
+              )
+            (vector+! gp-0 gp-0 (-> self root-override trans))
+            (setup-from-to-duration-and-height! (-> self traj) (-> self root-override trans) gp-0 225.0 f30-0)
+            )
+          (send-event (ppointer->process (-> self parent)) 'bomb-kicked)
+          (go-virtual back-atcha)
+          )
+         (else
+           (go-virtual explode)
+           )
+         )
+       )
+      (('fizzle)
+       (let* ((gp-1 (-> self clock frame-counter))
+              (f30-1 600.0)
+              (v1-34 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+              (v1-35 (the-as number (logior #x3f800000 v1-34)))
+              )
+         (set! (-> self fizzle-timer) (- gp-1 (the-as time-frame (the int (* f30-1 (+ -1.0 (the-as float v1-35)))))))
+         )
+       )
+      )
+    (none)
+    )
+  )
+
+;; definition for function widow-bomb-back-handler
+;; WARN: Return type mismatch object vs none.
+(defbehavior widow-bomb-back-handler widow-bomb ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (case arg2
+    (('impact-control)
+     (let* ((s4-0 (ppointer->process (-> self parent)))
+            (s5-0 (if (type? s4-0 widow)
+                      (the-as widow s4-0)
+                      )
+                  )
+            )
+       (when s5-0
+         (let ((a1-3 (vector<-cspace! (new 'stack-no-clear 'vector) (-> s5-0 node-list data 3))))
+           (when (and (< (vector-vector-distance (-> self root-override trans) a1-3) 49152.0) (not (-> s5-0 flying)))
+             (send-event s5-0 'bomb-hit (-> self root-override trans) 1)
+             (go-virtual explode)
+             )
+           )
+         )
+       )
+     (let ((s5-1 arg0))
+       (when (if (type? s5-1 widow)
+                 s5-1
+                 )
+         (send-event arg0 'bomb-hit (-> self root-override trans) 1)
+         (go-virtual explode)
+         )
+       )
+     )
+    (('fizzle)
+     (let* ((gp-1 (-> self clock frame-counter))
+            (f30-0 600.0)
+            (v1-34 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+            (v1-35 (the-as number (logior #x3f800000 v1-34)))
+            )
+       (set! (-> self fizzle-timer) (- gp-1 (the-as time-frame (the int (* f30-0 (+ -1.0 (the-as float v1-35)))))))
+       )
+     )
+    )
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate freefall (widow-bomb)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow-bomb) widow-bomb-back-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :trans (behavior ()
+    (if (and (nonzero? (-> self fizzle-timer))
+             (>= (- (-> self clock frame-counter) (-> self fizzle-timer)) (seconds 3))
+             )
+        (go-virtual explode)
+        )
+    (set! (-> self x-rotate) (+ 1092.2667 (-> self x-rotate)))
+    (set! (-> self y-rotate) (+ 728.1778 (-> self y-rotate)))
+    (widow-bomb-method-34 self)
+    (spawn-with-cspace (-> self part) (-> self node-list data 3))
+    (cond
+      ((>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 4))
+       (go-virtual explode)
+       )
+      (else
+        (vector-v++!
+          (-> self root-override transv)
+          (compute-acc-due-to-gravity (the-as collide-shape-moving (-> self root-override)) (new-stack-vector0) 1.0)
+          )
+        (let ((a2-1 (new 'stack-no-clear 'collide-query)))
+          (set! (-> a2-1 collide-with) (collide-spec backgnd enemy obstacle hit-by-others-list pusher))
+          (set! (-> a2-1 ignore-process0) self)
+          (set! (-> a2-1 ignore-process1) #f)
+          (set! (-> a2-1 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+          (set! (-> a2-1 action-mask) (collide-action solid))
+          (fill-cache-integrate-and-collide (-> self root-override) (-> self root-override transv) a2-1 (meters 0))
+          )
+        )
+      )
+    (ja :num! (loop!))
+    (none)
+    )
+  :code (the-as (function none :behavior widow-bomb) sleep-code)
+  :post (the-as (function none :behavior widow-bomb) transform-post)
+  )
+
+;; failed to figure out what this is:
+(defstate back-atcha (widow-bomb)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow-bomb) widow-bomb-back-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (initialize
+      (-> self impact)
+      self
+      3
+      4096.0
+      (collide-spec backgnd enemy obstacle hit-by-others-list player-list)
+      )
+    (let ((v1-5 (-> self root-override root-prim)))
+      (logior! (-> v1-5 prim-core collide-with) (collide-spec enemy))
+      (logclear! (-> v1-5 prim-core collide-with) (collide-spec jak))
+      )
+    (none)
+    )
+  :trans (behavior ()
+    (if (and (nonzero? (-> self fizzle-timer))
+             (>= (- (-> self clock frame-counter) (-> self fizzle-timer)) (seconds 3))
+             )
+        (go-virtual explode)
+        )
+    (set! (-> self x-rotate) (+ 4369.067 (-> self x-rotate)))
+    (set! (-> self y-rotate) (+ 3458.8445 (-> self y-rotate)))
+    (widow-bomb-method-34 self)
+    (cond
+      ((>= (- (-> self clock frame-counter) (-> self state-time)) (the int (-> self traj time)))
+       (compute-transv-at-time (-> self traj) (-> self traj time) (-> self root-override transv))
+       (vector-float*! (-> self root-override transv) (-> self root-override transv) 300.0)
+       (go-virtual freefall)
+       )
+      (else
+        (compute-trans-at-time
+          (-> self traj)
+          (the float (- (-> self clock frame-counter) (-> self state-time)))
+          (-> self root-override trans)
+          )
+        (update-from-cspace (-> self impact))
+        (when (>= (- (-> self clock frame-counter) (-> self state-time)) 1)
+          (let* ((a1-4 (new 'stack-no-clear 'collide-query))
+                 (f0-10 (impact-control-method-11
+                          (-> self impact)
+                          a1-4
+                          self
+                          (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noproj #x1 :noendlessfall #x1)
+                          )
+                        )
+                 )
+            (when (< 0.0 f0-10)
+              (set! (-> self root-override trans quad) (-> self impact trans 1 quad))
+              (compute-transv-at-time
+                (-> self traj)
+                (the float (- (-> self clock frame-counter) (-> self state-time)))
+                (-> self root-override transv)
+                )
+              (vector-float*! (-> self root-override transv) (-> self root-override transv) 300.0)
+              (go-virtual freefall)
+              )
+            )
+          )
+        (spawn-with-cspace (-> self part) (-> self node-list data 3))
+        )
+      )
+    (ja :num! (loop!))
+    (none)
+    )
+  :code (the-as (function none :behavior widow-bomb) sleep-code)
+  :post (the-as (function none :behavior widow-bomb) transform-post)
+  )
+
+;; failed to figure out what this is:
+(defstate explode (widow-bomb)
+  :virtual #t
+  :enter (behavior ()
+    (let* ((a0-1 (target-pos 0))
+           (f0-0 (vector-vector-distance-squared a0-1 (-> self root-override trans)))
+           (f1-0 16384.0)
+           )
+      (when (< f0-0 (* f1-0 f1-0))
+        (let ((a1-1 (new 'stack-no-clear 'event-message-block)))
+          (set! (-> a1-1 from) (process->ppointer self))
+          (set! (-> a1-1 num-params) 2)
+          (set! (-> a1-1 message) 'attack)
+          (set! (-> a1-1 param 0) (the-as uint #f))
+          (let ((v1-7 (new 'static 'attack-info :mask (attack-info-mask mode shove-back shove-up id))))
+            (let* ((a0-3 *game-info*)
+                   (a2-1 (+ (-> a0-3 attack-id) 1))
+                   )
+              (set! (-> a0-3 attack-id) a2-1)
+              (set! (-> v1-7 id) a2-1)
+              )
+            (set! (-> v1-7 mode) 'explode)
+            (set! (-> v1-7 shove-up) 16384.0)
+            (set! (-> v1-7 shove-back) 8192.0)
+            (set! (-> a1-1 param 1) (the-as uint v1-7))
+            )
+          (send-event-function *target* a1-1)
+          )
+        )
+      )
+    (activate! *camera-smush-control* 819.2 37 210 1.0 0.995 (-> self clock))
+    (ja-channel-set! 0)
+    (let ((v1-12 (-> self root-override root-prim)))
+      (set! (-> v1-12 prim-core collide-as) (collide-spec))
+      (set! (-> v1-12 prim-core collide-with) (collide-spec))
+      )
+    0
+    (sound-play "w-bomb-explode")
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :trans (behavior ()
+    (cond
+      ((< (- (-> self clock frame-counter) (-> self state-time)) (seconds 2))
+       (let ((a1-0 (new 'stack-no-clear 'vector)))
+         (set! (-> a1-0 quad) (-> self root-override trans quad))
+         (set! (-> a1-0 y) (+ 2048.0 (-> a1-0 y)))
+         (spawn (-> self explode-part) a1-0)
+         )
+       )
+      ((not (-> self child))
+       (deactivate self)
+       )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior widow-bomb) sleep-code)
+  :post (the-as (function none :behavior widow-bomb) ja-post)
+  )
+
+;; definition for method 32 of type widow-bomb
+;; WARN: Return type mismatch int vs none.
+(defmethod widow-bomb-method-32 widow-bomb ((obj widow-bomb))
+  (with-pp
+    (spawn-with-cspace (-> obj part) (-> obj node-list data 3))
+    (sound-play "w-bomb-steam" :id (the-as sound-id (-> obj steam-sound)) :position (-> obj root-override trans))
+    (let ((s5-0 (the-as int (- (-> pp clock frame-counter) (-> obj state-time)))))
+      (if (nonzero? (-> obj fizzle-timer))
+          (set! s5-0 (max
+                       (the-as time-frame s5-0)
+                       (- (seconds 12) (- (seconds 3) (- (-> pp clock frame-counter) (-> obj fizzle-timer))))
+                       )
+                )
+          )
+      (if (< 3600 s5-0)
+          (go (method-of-object obj explode))
+          )
+      (when (< 3000 s5-0)
+        (spawn-with-cspace (-> obj warning-spark-part) (-> obj node-list data 3))
+        (when (not (-> obj firework-sound-played))
+          (set! (-> obj firework-sound-played) #t)
+          (sound-play "w-bomb-firewrks")
+          )
+        )
+      (let* ((v1-27 (* s5-0 s5-0))
+             (a0-10 3600)
+             (v1-28 (- (* a0-10 a0-10) v1-27))
+             )
+        (when (< v1-28 (-> obj next-countdown-tick))
+          (let ((a0-14 540))
+            (set! (-> obj next-countdown-tick) (the-as time-frame (- v1-28 (mod v1-28 (* a0-14 a0-14)))))
+            )
+          (let ((s5-2 (new 'stack-no-clear 'vector)))
+            (vector<-cspace! s5-2 (-> obj node-list data 7))
+            (spawn (-> obj warning-glow-part) s5-2)
+            (vector<-cspace! s5-2 (-> obj node-list data 6))
+            (spawn (-> obj warning-glow-part) s5-2)
+            (vector<-cspace! s5-2 (-> obj node-list data 5))
+            (spawn (-> obj warning-glow-part) s5-2)
+            (vector<-cspace! s5-2 (-> obj node-list data 4))
+            (spawn (-> obj warning-glow-part) s5-2)
+            )
+          (sound-play "w-bomb-timer")
+          )
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate smoke (widow-bomb)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior widow-bomb) widow-bomb-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (let* ((v1-2 3600)
+           (v1-3 (* v1-2 v1-2))
+           (a0-0 540)
+           )
+      (set! (-> self next-countdown-tick) (the-as time-frame (- v1-3 (mod v1-3 (* a0-0 a0-0)))))
+      )
+    (set! (-> self steam-sound) (the-as uint (new-sound-id)))
+    (none)
+    )
+  :exit (behavior ()
+    (sound-stop (the-as sound-id (-> self steam-sound)))
+    (none)
+    )
+  :trans (behavior ()
+    (widow-bomb-method-32 self)
+    (ja :num! (loop!))
+    (none)
+    )
+  :code (the-as (function none :behavior widow-bomb) sleep-code)
+  :post (the-as (function none :behavior widow-bomb) ja-post)
+  )
+
+;; definition for method 33 of type widow-bomb
+(defmethod widow-bomb-method-33 widow-bomb ((obj widow-bomb))
+  (let ((gp-0 (new 'stack-no-clear 'matrix)))
+    (set-vector! (-> gp-0 vector 1) 0.0 1.0 0.0 1.0)
+    (vector-! (-> gp-0 vector 2) (the-as vector (-> obj impact trans)) (-> obj impact trans 1))
+    (vector-cross! (the-as vector (-> gp-0 vector)) (-> gp-0 vector 1) (-> gp-0 vector 2))
+    (vector-normalize! (the-as vector (-> gp-0 vector)) 1.0)
+    (vector-cross! (-> gp-0 vector 2) (the-as vector (-> gp-0 vector)) (-> gp-0 vector 1))
+    (vector<-cspace! (-> gp-0 trans) (-> obj node-list data 3))
+    (set! (-> gp-0 vector 0 w) 0.0)
+    (set! (-> gp-0 vector 1 w) 0.0)
+    (set! (-> gp-0 vector 2 w) 0.0)
+    (set! (-> gp-0 trans w) 1.0)
+    (spawn-with-matrix (-> obj skid-part) gp-0)
+    )
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate idle (widow-bomb)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (let ((v1-0 event-type))
+      (the-as
+        object
+        (cond
+          ((or (= v1-0 'touch) (= v1-0 'bonk))
+           (when (< (-> self which-trajectory) 2)
+             (let ((a1-1 (new 'stack-no-clear 'event-message-block)))
+               (set! (-> a1-1 from) (process->ppointer self))
+               (set! (-> a1-1 num-params) 2)
+               (set! (-> a1-1 message) 'attack)
+               (set! (-> a1-1 param 0) (the-as uint #f))
+               (let ((v1-5 (new 'static 'attack-info :mask (attack-info-mask shove-back shove-up id))))
+                 (let* ((a0-2 *game-info*)
+                        (a2-2 (+ (-> a0-2 attack-id) 1))
+                        )
+                   (set! (-> a0-2 attack-id) a2-2)
+                   (set! (-> v1-5 id) a2-2)
+                   )
+                 (set! (-> v1-5 shove-up) 4096.0)
+                 (set! (-> v1-5 shove-back) 12288.0)
+                 (set! (-> a1-1 param 1) (the-as uint v1-5))
+                 )
+               (send-event-function *target* a1-1)
+               )
+             )
+           )
+          ((= v1-0 'impact-control)
+           (if (and (!= proc self) (!= proc (-> self parent)))
+               (send-event proc 'bomb-hit (-> self root-override trans) 1)
+               )
+           )
+          ((= v1-0 'fizzle)
+           (let* ((gp-0 (-> self clock frame-counter))
+                  (f30-0 600.0)
+                  (v1-17 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                  (v1-18 (the-as number (logior #x3f800000 v1-17)))
+                  (v0-0 (the-as object (- gp-0 (the-as time-frame (the int (* f30-0 (+ -1.0 (the-as float v1-18))))))))
+                  )
+             (set! (-> self fizzle-timer) (the-as time-frame v0-0))
+             v0-0
+             )
+           )
+          (else
+            (the-as object (widow-bomb-handler proc arg1 event-type event))
+            )
+          )
+        )
+      )
+    )
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (initialize (-> self impact) self 3 4096.0 (collide-spec backgnd obstacle hit-by-others-list player-list))
+    (none)
+    )
+  :exit (behavior ()
+    (when (nonzero? (-> self fizzle-timer))
+      (let* ((gp-0 (-> self clock frame-counter))
+             (f30-0 600.0)
+             (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+             (v1-5 (the-as number (logior #x3f800000 v1-4)))
+             )
+        (set! (-> self fizzle-timer) (- gp-0 (the-as time-frame (the int (* f30-0 (+ -1.0 (the-as float v1-5)))))))
+        )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    (let ((v1-0 (-> self which-trajectory)))
+      (cond
+        ((zero? v1-0)
+         (set! (-> self x-rotate) (+ 4369.067 (-> self x-rotate)))
+         (set! (-> self y-rotate) (+ 3458.8445 (-> self y-rotate)))
+         )
+        ((= v1-0 1)
+         (set! (-> self x-rotate) (+ 7281.778 (-> self x-rotate)))
+         (set! (-> self y-rotate) 0.0)
+         )
+        (else
+          (seek! (-> self x-rotate) 65353.957 7281.778)
+          )
+        )
+      )
+    (if (< 65536.0 (-> self x-rotate))
+        (set! (-> self x-rotate) (+ -65536.0 (-> self x-rotate)))
+        )
+    (if (< 65536.0 (-> self y-rotate))
+        (set! (-> self y-rotate) (+ -65536.0 (-> self y-rotate)))
+        )
+    (widow-bomb-method-34 self)
+    (when (< (-> self root-override scale x) 1.0)
+      (let ((f0-17 (fmin 1.0 (+ 0.025 (-> self root-override scale x)))))
+        (set-vector! (-> self root-override scale) f0-17 f0-17 f0-17 1.0)
+        )
+      )
+    (cond
+      ((>= (- (-> self clock frame-counter) (-> self state-time)) (the int (-> self traj time)))
+       (let ((v1-29 (-> self which-trajectory)))
+         (cond
+           ((zero? v1-29)
+            (set! (-> self which-trajectory) 1)
+            (compute-trans-at-time
+              (-> self traj)
+              (fmin (-> self traj time) (the float (- (-> self clock frame-counter) (-> self state-time))))
+              (-> self root-override trans)
+              )
+            (set! (-> self state-time) (-> self clock frame-counter))
+            (let ((gp-1 (vector-! (new 'stack-no-clear 'vector) (-> self root-override trans) (the-as vector (-> self traj)))))
+              (set! (-> gp-1 y) 0.0)
+              (vector-normalize! gp-1 12288.0)
+              (vector+! gp-1 gp-1 (-> self root-override trans))
+              (setup-from-to-duration-and-height! (-> self traj) (-> self root-override trans) gp-1 75.0 4096.0)
+              )
+            (widow-bomb-method-33 self)
+            (sound-play "w-bomb-part1")
+            )
+           ((= v1-29 1)
+            (set! (-> self which-trajectory) 2)
+            (compute-trans-at-time
+              (-> self traj)
+              (fmin (-> self traj time) (the float (- (-> self clock frame-counter) (-> self state-time))))
+              (-> self root-override trans)
+              )
+            (set! (-> self state-time) (-> self clock frame-counter))
+            (let ((gp-4 (vector-! (new 'stack-no-clear 'vector) (-> self root-override trans) (the-as vector (-> self traj)))))
+              (set! (-> gp-4 y) 0.0)
+              (vector-normalize! gp-4 4096.0)
+              (vector+! gp-4 gp-4 (-> self root-override trans))
+              (setup-from-to-duration-and-height! (-> self traj) (-> self root-override trans) gp-4 37.5 1024.0)
+              )
+            (widow-bomb-method-33 self)
+            (sound-play "w-bomb-part2")
+            )
+           ((= v1-29 2)
+            (compute-trans-at-time
+              (-> self traj)
+              (fmin (-> self traj time) (the float (- (-> self clock frame-counter) (-> self state-time))))
+              (-> self root-override trans)
+              )
+            (set! (-> self which-trajectory) 3)
+            (let* ((gp-6 (-> self state-time))
+                   (f30-0 300.0)
+                   (v1-77 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
+                   (v1-78 (the-as number (logior #x3f800000 v1-77)))
+                   )
+              (set! (-> self state-time) (+ gp-6 (the int (* f30-0 (+ -1.0 (the-as float v1-78))))))
+              )
+            (widow-bomb-method-33 self)
+            )
+           (else
+             (go-virtual smoke)
+             )
+           )
+         )
+       )
+      ((< (-> self which-trajectory) 3)
+       (compute-trans-at-time
+         (-> self traj)
+         (fmin (-> self traj time) (the float (- (-> self clock frame-counter) (-> self state-time))))
+         (-> self root-override trans)
+         )
+       (when (and (zero? (-> self which-trajectory))
+                  (< (- (-> self clock frame-counter) (-> self state-time)) (the int (* 0.75 (-> self traj time))))
+                  )
+         (vector+float*! (-> self launch-pos) (-> self launch-pos) (-> self launch) (-> self clock time-adjust-ratio))
+         (vector-lerp!
+           (-> self root-override trans)
+           (-> self launch-pos)
+           (-> self root-override trans)
+           (parameter-ease-sin-clamp
+             (* 1.3333334 (/ (the float (- (-> self clock frame-counter) (-> self state-time))) (-> self traj time)))
+             )
+           )
+         )
+       (spawn-with-cspace (-> self trail-part) (-> self node-list data 3))
+       (when (zero? (-> self which-trajectory))
+         (update-from-cspace (-> self impact))
+         (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.05))
+           (let ((f0-42 (impact-control-method-11
+                          (-> self impact)
+                          (new 'stack-no-clear 'collide-query)
+                          self
+                          (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)
+                          )
+                        )
+                 )
+             (if (< 0.0 f0-42)
+                 (go-virtual explode)
+                 )
+             )
+           )
+         )
+       )
+      )
+    (ja :num! (loop!))
+    (none)
+    )
+  :code (the-as (function none :behavior widow-bomb) sleep-code)
+  :post (behavior ()
+    (transform-post)
+    (do-push-aways (-> self root-override))
+    (none)
+    )
+  )
+
+;; definition for method 10 of type widow-bomb
+(defmethod deactivate widow-bomb ((obj widow-bomb))
+  (if (nonzero? (-> obj explode-part))
+      (kill-and-free-particles (-> obj explode-part))
+      )
+  (if (nonzero? (-> obj trail-part))
+      (kill-and-free-particles (-> obj trail-part))
+      )
+  (if (nonzero? (-> obj warning-glow-part))
+      (kill-and-free-particles (-> obj warning-glow-part))
+      )
+  (if (nonzero? (-> obj warning-spark-part))
+      (kill-and-free-particles (-> obj warning-spark-part))
+      )
+  (if (nonzero? (-> obj skid-part))
+      (kill-and-free-particles (-> obj warning-spark-part))
+      )
+  ((the-as (function process-drawable none) (find-parent-method widow-bomb 10)) obj)
+  (none)
+  )
+
+;; definition for method 7 of type widow-bomb
+;; WARN: Return type mismatch process-drawable vs widow-bomb.
+(defmethod relocate widow-bomb ((obj widow-bomb) (arg0 int))
+  (if (nonzero? (-> obj explode-part))
+      (&+! (-> obj explode-part) arg0)
+      )
+  (if (nonzero? (-> obj trail-part))
+      (&+! (-> obj trail-part) arg0)
+      )
+  (if (nonzero? (-> obj warning-glow-part))
+      (&+! (-> obj warning-glow-part) arg0)
+      )
+  (if (nonzero? (-> obj warning-spark-part))
+      (&+! (-> obj warning-spark-part) arg0)
+      )
+  (if (nonzero? (-> obj skid-part))
+      (&+! (-> obj skid-part) arg0)
+      )
+  (if (nonzero? (-> obj spin-jm))
+      (&+! (-> obj spin-jm) arg0)
+      )
+  (the-as
+    widow-bomb
+    ((the-as (function process-drawable int process-drawable) (find-parent-method widow-bomb 7)) obj arg0)
+    )
+  )
+
+;; definition for function widow-bomb-reaction
+(defbehavior widow-bomb-reaction widow ((arg0 control-info) (arg1 collide-query) (arg2 vector) (arg3 vector))
+  (cshape-reaction-update-state arg0 arg1 arg3)
+  (vector--float*!
+    arg2
+    arg3
+    (-> arg0 surface-normal)
+    (* (vector-dot arg3 (-> arg0 surface-normal)) (rand-vu-float-range 1.2 1.4))
+    )
+  (send-event (-> arg0 process) 'impact-control)
+  (-> arg0 status)
+  )
+
+;; definition for function widow-bomb-init-by-other
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defbehavior widow-bomb-init-by-other widow-bomb ((arg0 vector) (arg1 vector) (arg2 float) (arg3 float) (arg4 vector))
+  (let ((s1-0 (new 'process 'collide-shape-moving self (collide-list-enum usually-hit-by-player))))
+    (set! (-> s1-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s1-0 reaction) widow-bomb-reaction)
+    (set! (-> s1-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((v1-6 (new 'process 'collide-shape-prim-sphere s1-0 (the-as uint 0))))
+      (set! (-> v1-6 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-6 prim-core collide-with) (collide-spec backgnd jak bot hit-by-others-list player-list))
+      (set! (-> v1-6 prim-core action) (collide-action solid))
+      (set! (-> v1-6 transform-index) 3)
+      (set-vector! (-> v1-6 local-sphere) 0.0 0.0 0.0 4096.0)
+      (set! (-> s1-0 total-prims) (the-as uint 1))
+      (set! (-> s1-0 root-prim) v1-6)
+      )
+    (set! (-> s1-0 nav-radius) (* 0.75 (-> s1-0 root-prim local-sphere w)))
+    (let ((v1-9 (-> s1-0 root-prim)))
+      (set! (-> s1-0 backup-collide-as) (-> v1-9 prim-core collide-as))
+      (set! (-> s1-0 backup-collide-with) (-> v1-9 prim-core collide-with))
+      )
+    (set! (-> s1-0 event-self) 'impact-control)
+    (set! (-> self root-override) s1-0)
+    )
+  (set! (-> self root-override trans quad) (-> arg0 quad))
+  (initialize-skeleton
+    self
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-widow-bomb" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> self part) (create-launch-control (-> *part-group-id-table* 712) self))
+  (set! (-> self explode-part) (create-launch-control (-> *part-group-id-table* 711) self))
+  (set! (-> self trail-part) (create-launch-control (-> *part-group-id-table* 722) self))
+  (set! (-> self warning-glow-part) (create-launch-control (-> *part-group-id-table* 724) self))
+  (set! (-> self warning-spark-part) (create-launch-control (-> *part-group-id-table* 723) self))
+  (set! (-> self skid-part) (create-launch-control (-> *part-group-id-table* 725) self))
+  (set-vector! (-> self root-override scale) 0.5 0.5 0.5 1.0)
+  (if (< (-> arg0 y) (-> arg1 y))
+      (set! arg3 (+ arg3 (- (-> arg1 y) (-> arg0 y))))
+      )
+  (let ((a3-3 (* 0.0000061035157 (vector-vector-xz-distance arg0 arg1) arg2)))
+    (setup-from-to-duration-and-height! (-> self traj) arg0 arg1 a3-3 arg3)
+    )
+  (let ((v1-42 (new 'stack-no-clear 'vector)))
+    (vector-! v1-42 arg1 arg0)
+    (set! (-> v1-42 y) 0.0)
+    (let ((f30-1 (atan (-> v1-42 x) (-> v1-42 z))))
+      (quaternion-set! (-> self root-override quat) 0.0 (sin (* 0.5 f30-1)) 0.0 (cos (* 0.5 f30-1)))
+      )
+    )
+  (set! (-> self which-trajectory) 0)
+  (set! (-> self x-rotate) 0.0)
+  (set! (-> self y-rotate) 0.0)
+  (logclear! (-> self mask) (process-mask actor-pause))
+  (set! (-> self spin-jm) (new 'process 'joint-mod (joint-mod-mode joint-set*) self 3))
+  (set! (-> self firework-sound-played) #f)
+  (set! (-> self steam-sound) (the-as uint 0))
+  (set! (-> self launch-pos quad) (-> self root-override trans quad))
+  (set! (-> self launch quad) (-> arg4 quad))
+  (set! (-> self fizzle-timer) 0)
+  (go-virtual idle)
+  (none)
+  )
+
+;; definition of type heart-mar
+(deftype heart-mar (process-drawable)
+  ((root-override collide-shape-moving  :offset 128)
+   )
+  :heap-base #x50
+  :method-count-assert 21
+  :size-assert         #xc8
+  :flag-assert         #x15005000c8
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+;; definition for method 3 of type heart-mar
+(defmethod inspect heart-mar ((obj heart-mar))
+  (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-heart-mar heart-mar heart-mar-lod0-jg heart-mar-idle-ja
+              ((heart-mar-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              :origin-joint-index 3
+              )
+
+;; failed to figure out what this is:
+(defstate idle (heart-mar)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as object (case event-type
+                     (('frame)
+                      (let ((v1-3 (ja-group)))
+                        (when (not (and v1-3 (= v1-3 (-> self draw art-group data 3))))
+                          (ja :group! (-> self draw art-group data 3) :num! min)
+                          (set! (-> self draw bounds w) 81920.0)
+                          (setup-masks (-> self draw) 2 0)
+                          )
+                        )
+                      (if (and (< (ja-aframe-num 0) 775.0) (>= (the-as float (-> event param 0)) 775.0))
+                          (setup-masks (-> self draw) 0 4)
+                          )
+                      (if (>= (the-as float (-> event param 0)) 834.0)
+                          (deactivate self)
+                          )
+                      (set-tombboss-gem-light! (lerp-scale 1.0 0.0 (ja-aframe-num 0) 760.0 800.0))
+                      (ja :num-func num-func-identity :frame-num (ja-aframe (the-as float (-> event param 0)) 0))
+                      (let ((v0-9 (logclear (-> self mask) (process-mask sleep-code))))
+                        (set! (-> self mask) v0-9)
+                        v0-9
+                        )
+                      )
+                     (('grab-done)
+                      (the-as process-mask (deactivate self))
+                      )
+                     )
+            )
+    )
+  :code (behavior ()
+    (until #f
+      (logior! (-> self mask) (process-mask sleep-code))
+      (suspend)
+      (ja-post)
+      )
+    #f
+    (none)
+    )
+  )
+
+;; definition for function heart-mar-init-by-other
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defbehavior heart-mar-init-by-other heart-mar ((arg0 vector))
+  (set! (-> self root-override) (the-as collide-shape-moving (new 'process 'trsqv)))
+  (set! (-> self root-override trans quad) (-> arg0 quad))
+  (initialize-skeleton
+    self
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-heart-mar" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (setup-masks (-> self draw) 0 2)
+  (quaternion-set! (-> self root-override quat) 0.0 1.0 0.0 0.0)
+  (set! (-> self root-override pause-adjust-distance) 245760.0)
+  (ja-post)
+  (add-connection *part-engine* self 3 self 3253 (new 'static 'vector :w 819200.0))
+  (set! (-> self draw light-index) (the-as uint 17))
+  (set-tombboss-gem-light! 1.0)
+  (go-virtual idle)
+  (none)
+  )
+
+;; definition of type tomb-boss-pillar
+(deftype tomb-boss-pillar (process-drawable)
+  ((root-override   collide-shape-moving      :offset        128)
+   (explode-part    sparticle-launch-control  :offset-assert 200)
+   (segs-shot       int32                     :offset-assert 204)
+   (last-pillar-hit time-frame                :offset-assert 208)
+   )
+  :heap-base #x60
+  :method-count-assert 23
+  :size-assert         #xd8
+  :flag-assert         #x17006000d8
+  (:methods
+    (idle () _type_ :state 20)
+    (break-it () _type_ :state 21)
+    (broken () _type_ :state 22)
+    )
+  )
+
+;; definition for method 3 of type tomb-boss-pillar
+(defmethod inspect tomb-boss-pillar ((obj tomb-boss-pillar))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Texplode-part: ~A~%" (-> obj explode-part))
+  (format #t "~2Tsegs-shot: ~D~%" (-> obj segs-shot))
+  (format #t "~2Tlast-pillar-hit: ~D~%" (-> obj last-pillar-hit))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-tomb-boss-pillar tomb-boss-pillar tomb-boss-pillar-lod0-jg tomb-boss-pillar-idle-ja
+              ((tomb-boss-pillar-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 4 0 9)
+              )
+
+;; definition for function damage-pillar
+(defbehavior damage-pillar tomb-boss-pillar ()
+  (case (-> self segs-shot)
+    ((1)
+     (setup-masks (-> self draw) 0 2)
+     )
+    ((2)
+     (setup-masks (-> self draw) 0 6)
+     )
+    ((3)
+     (setup-masks (-> self draw) 0 14)
+     )
+    ((4)
+     (setup-masks (-> self draw) 0 30)
+     )
+    ((5)
+     (setup-masks (-> self draw) 0 62)
+     )
+    ((6)
+     (setup-masks (-> self draw) 0 126)
+     )
+    ((7)
+     (setup-masks (-> self draw) 0 254)
+     )
+    ((8)
+     (setup-masks (-> self draw) 0 510)
+     )
+    ((9)
+     (setup-masks (-> self draw) 0 1022)
+     )
+    ((10)
+     (setup-masks (-> self draw) 0 2046)
+     )
+    ((11)
+     (setup-masks (-> self draw) 0 4094)
+     )
+    ((12)
+     (setup-masks (-> self draw) 0 8190)
+     )
+    ((13)
+     (setup-masks (-> self draw) 0 #x3ffe)
+     )
+    ((14)
+     (setup-masks (-> self draw) 0 #x7ffe)
+     )
+    ((15)
+     (setup-masks (-> self draw) 0 #xfffe)
+     )
+    ((16)
+     (setup-masks (-> self draw) 0 #x1fffe)
+     )
+    )
+  (none)
+  )
+
+;; definition for function tomb-boss-pillar-shrink-collision
+;; WARN: Return type mismatch int vs none.
+(defbehavior tomb-boss-pillar-shrink-collision tomb-boss-pillar ()
+  (let ((v1-1 (the-as collide-shape-prim-group (-> self root-override root-prim))))
+    (let ((a0-1 (-> v1-1 child 0)))
+      (set! (-> a0-1 prim-core collide-as) (collide-spec))
+      (set! (-> a0-1 prim-core collide-with) (collide-spec))
+      )
+    0
+    (let ((v1-3 (-> v1-1 child 1)))
+      (set! (-> v1-3 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-3 prim-core collide-with) (collide-spec jak bot player-list))
+      )
+    )
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate broken (tomb-boss-pillar)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self draw bounds w) 36864.0)
+    (ja :group! (-> self draw art-group data 4)
+        :num! (identity (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 4)) frames num-frames) -1)))
+        )
+    (tomb-boss-pillar-shrink-collision)
+    (ja-post)
+    (none)
+    )
+  :code (the-as (function none :behavior tomb-boss-pillar) sleep-code)
+  )
+
+;; failed to figure out what this is:
+(defstate break-it (tomb-boss-pillar)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self draw bounds w) 245760.0)
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :trans (behavior ()
+    (if (< (- (-> self clock frame-counter) (-> self state-time)) (seconds 1))
+        (spawn-with-cspace (-> self explode-part) (-> self node-list data 6))
+        )
+    (let ((v1-9 (ja-group)))
+      (cond
+        ((and v1-9 (= v1-9 (-> self draw art-group data 4)))
+         (ja :num! (seek!))
+         (if (ja-done? 0)
+             (go-virtual broken)
+             )
+         )
+        (else
+          (ja :group! (-> self draw art-group data 4) :num! min)
+          (activate! *camera-smush-control* 819.2 37 210 1.0 0.995 (-> self clock))
+          )
+        )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior tomb-boss-pillar) sleep-code)
+  :post (the-as (function none :behavior tomb-boss-pillar) ja-post)
+  )
+
+;; failed to figure out what this is:
+(defstate idle (tomb-boss-pillar)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('attack)
+       (let ((gp-0 proc))
+         (when (if (type? gp-0 widow-shot)
+                   gp-0
+                   )
+           (+! (-> self segs-shot) 1)
+           (damage-pillar)
+           (cond
+             ((>= (-> self segs-shot) 16)
+              (go-virtual break-it)
+              )
+             ((>= (- (-> self clock frame-counter) (-> self last-pillar-hit)) (seconds 2))
+              (process-spawn
+                part-tracker
+                :init part-tracker-init
+                (-> *part-group-id-table* 718)
+                0
+                #f
+                #f
+                self
+                0
+                :to *entity-pool*
+                )
+              (set! (-> self last-pillar-hit) (-> self clock frame-counter))
+              (sound-play "pillar-hit" :position (-> self root-override trans))
+              )
+             )
+           )
+         )
+       )
+      )
+    )
+  :enter (behavior ()
+    (let ((v1-3 (-> (the-as collide-shape-prim-group (-> self root-override root-prim)) child 1)))
+      (set! (-> v1-3 prim-core collide-as) (collide-spec))
+      (set! (-> v1-3 prim-core collide-with) (collide-spec))
+      )
+    0
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :exit (behavior ()
+    (let ((v1-2 (-> self entity extra perm)))
+      (logior! (-> v1-2 status) (entity-perm-status bit-5))
+      (set! (-> v1-2 user-object 1) (-> self segs-shot))
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior tomb-boss-pillar) sleep-code)
+  )
+
+;; definition for method 10 of type tomb-boss-pillar
+(defmethod deactivate tomb-boss-pillar ((obj tomb-boss-pillar))
+  (if (nonzero? (-> obj explode-part))
+      (kill-and-free-particles (-> obj explode-part))
+      )
+  ((the-as (function process-drawable none) (find-parent-method tomb-boss-pillar 10)) obj)
+  (none)
+  )
+
+;; definition for method 7 of type tomb-boss-pillar
+;; WARN: Return type mismatch process-drawable vs tomb-boss-pillar.
+(defmethod relocate tomb-boss-pillar ((obj tomb-boss-pillar) (arg0 int))
+  (if (nonzero? (-> obj explode-part))
+      (&+! (-> obj explode-part) arg0)
+      )
+  (the-as
+    tomb-boss-pillar
+    ((the-as (function process-drawable int process-drawable) (find-parent-method tomb-boss-pillar 7)) obj arg0)
+    )
+  )
+
+;; definition for method 11 of type tomb-boss-pillar
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! tomb-boss-pillar ((obj tomb-boss-pillar) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (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))
+      (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 0.0 0.0 16384.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (let ((v1-9 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-9 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-9 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-9 prim-core action) (collide-action solid))
+      (set! (-> v1-9 transform-index) 3)
+      (set-vector! (-> v1-9 local-sphere) 0.0 0.0 0.0 16384.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 0.0 0.0 8192.0)
+      )
+    (set! (-> s4-0 nav-radius) 8192.0)
+    (let ((v1-13 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-13 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-13 prim-core collide-with))
+      )
+    (set! (-> obj root-override) (the-as collide-shape-moving s4-0))
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-pillar" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (transform-post)
+  (set! (-> obj explode-part) (create-launch-control (-> *part-group-id-table* 719) obj))
+  (set! (-> obj last-pillar-hit) 0)
+  (let ((v1-23 (-> obj entity extra perm)))
+    (logior! (-> v1-23 status) (entity-perm-status bit-5))
+    (set! (-> obj segs-shot) (the-as int (-> v1-23 user-object 1)))
+    )
+  (damage-pillar)
+  (if (>= (-> obj segs-shot) 16)
+      (go (method-of-object obj broken))
+      (go (method-of-object obj idle))
+      )
+  (none)
+  )
+
+;; definition of type tomb-boss-firepot
+(deftype tomb-boss-firepot (process-drawable)
+  ((root-override collide-shape-moving  :offset 128)
+   )
+  :heap-base #x50
+  :method-count-assert 23
+  :size-assert         #xc8
+  :flag-assert         #x17005000c8
+  (:methods
+    (idle () _type_ :state 20)
+    (break-it () _type_ :state 21)
+    (broken () _type_ :state 22)
+    )
+  )
+
+;; definition for method 3 of type tomb-boss-firepot
+(defmethod inspect tomb-boss-firepot ((obj tomb-boss-firepot))
+  (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-tomb-boss-firepot tomb-boss-firepot tomb-boss-firepot-lod0-jg tomb-boss-firepot-idle-ja
+              ((tomb-boss-firepot-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 4 0 9)
+              )
+
+;; definition for function tomb-boss-firepot-shrink-collision
+;; WARN: Return type mismatch int vs none.
+(defbehavior tomb-boss-firepot-shrink-collision tomb-boss-firepot ()
+  (let ((v1-1 (the-as collide-shape-prim-group (-> self root-override root-prim))))
+    (let ((a0-1 (-> v1-1 child 0)))
+      (set! (-> a0-1 prim-core collide-as) (collide-spec))
+      (set! (-> a0-1 prim-core collide-with) (collide-spec))
+      )
+    0
+    (let ((v1-3 (-> v1-1 child 1)))
+      (set! (-> v1-3 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-3 prim-core collide-with) (collide-spec jak bot player-list))
+      )
+    )
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate broken (tomb-boss-firepot)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self draw bounds w) 36864.0)
+    (ja :group! (-> self draw art-group data 4)
+        :num! (identity (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 4)) frames num-frames) -1)))
+        )
+    (tomb-boss-firepot-shrink-collision)
+    (ja-post)
+    (none)
+    )
+  :code (the-as (function none :behavior tomb-boss-firepot) sleep-code)
+  )
+
+;; failed to figure out what this is:
+(defstate break-it (tomb-boss-firepot)
+  :virtual #t
+  :enter (behavior ()
+    (process-entity-status! self (entity-perm-status subtask-complete) #t)
+    (tomb-boss-firepot-shrink-collision)
+    (set! (-> self draw bounds w) 245760.0)
+    (ja :group! (-> self draw art-group data 4) :num! min)
+    (let ((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-4 gp-1)
+              (a1-4 part-tracker-init)
+              (a2-6 (-> *part-group-id-table* 720))
+              (a3-1 0)
+              (t0-0 #f)
+              (t1-0 #f)
+              (t2-0 #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-5)
+           a0-4
+           a1-4
+           a2-6
+           a3-1
+           t0-0
+           t1-0
+           t2-0
+           t3-0
+           )
+          )
+        (-> gp-1 ppointer)
+        )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    (ja :num! (seek!))
+    (if (ja-done? 0)
+        (go-virtual broken)
+        )
+    (none)
+    )
+  :code (the-as (function none :behavior tomb-boss-firepot) sleep-code)
+  :post (the-as (function none :behavior tomb-boss-firepot) ja-post)
+  )
+
+;; failed to figure out what this is:
+(defstate idle (tomb-boss-firepot)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('attack)
+       (let ((gp-0 proc))
+         (when (if (type? gp-0 widow-shot)
+                   (the-as widow-shot gp-0)
+                   )
+           (let ((v1-2 (the-as object (-> event param 1)))
+                 (gp-1 (new 'stack-no-clear 'vector))
+                 )
+             (cond
+               ((logtest? (attack-info-mask attacker-velocity) (-> (the-as attack-info v1-2) mask))
+                (set! (-> gp-1 quad) (-> (the-as attack-info v1-2) attacker-velocity quad))
+                )
+               (else
+                 (let* ((a3-1 (the-as object (-> event param 0)))
+                        (a1-4 (-> (the-as touching-shapes-entry a3-1) head))
+                        )
+                   (get-intersect-point gp-1 a1-4 (-> self root-override) (the-as touching-shapes-entry a3-1))
+                   )
+                 (vector-! gp-1 (-> self root-override trans) gp-1)
+                 )
+               )
+             (let ((s5-1 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))))
+               (vector-flatten! gp-1 gp-1 (-> s5-1 vector 1))
+               (when (!= (vector-normalize-ret-len! gp-1 1.0) 0.0)
+                 (set! (-> s5-1 vector 2 quad) (-> gp-1 quad))
+                 (vector-cross! (the-as vector (-> s5-1 vector)) (-> s5-1 vector 1) (-> s5-1 vector 2))
+                 (matrix->quaternion (-> self root-override quat) s5-1)
+                 )
+               )
+             )
+           (go-virtual break-it)
+           )
+         )
+       )
+      )
+    )
+  :enter (behavior ()
+    (let ((v1-3 (-> (the-as collide-shape-prim-group (-> self root-override root-prim)) child 1)))
+      (set! (-> v1-3 prim-core collide-as) (collide-spec))
+      (set! (-> v1-3 prim-core collide-with) (collide-spec))
+      )
+    0
+    (none)
+    )
+  :code (the-as (function none :behavior tomb-boss-firepot) sleep-code)
+  )
+
+;; definition for method 11 of type tomb-boss-firepot
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! tomb-boss-firepot ((obj tomb-boss-firepot) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (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))
+      (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) 5)
+      (set-vector! (-> s3-0 local-sphere) 0.0 0.0 0.0 16384.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (let ((v1-9 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-9 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-9 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-9 prim-core action) (collide-action solid))
+      (set! (-> v1-9 transform-index) 5)
+      (set-vector! (-> v1-9 local-sphere) 0.0 0.0 0.0 16384.0)
+      )
+    (let ((v1-11 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (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) 5)
+      (set-vector! (-> v1-11 local-sphere) 0.0 0.0 0.0 16384.0)
+      )
+    (set! (-> s4-0 nav-radius) 8192.0)
+    (let ((v1-13 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-13 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-13 prim-core collide-with))
+      )
+    (set! (-> obj root-override) (the-as collide-shape-moving s4-0))
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-firepot" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj root-override pause-adjust-distance) 245760.0)
+  (transform-post)
+  (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 for method 15 of type hud-widow
+;; WARN: Return type mismatch int vs none.
+(defmethod draw hud-widow ((obj hud-widow))
+  (set-hud-piece-position! (-> obj sprites 1) (the int (+ 462.0 (* 130.0 (-> obj offset)))) 350)
+  (set-as-offset-from! (the-as hud-sprite (-> obj sprites)) (the-as vector4w (-> obj sprites 1)) -32 0)
+  (set-as-offset-from! (-> obj sprites 5) (the-as vector4w (-> obj sprites 1)) -62 14)
+  (set-as-offset-from! (-> obj sprites 6) (the-as vector4w (-> obj sprites 1)) -32 14)
+  (let ((s5-0 (-> obj values 0 current))
+        (f30-0 (* 0.01 (the float (-> obj values 1 current))))
+        )
+    (set-as-offset-from! (-> obj sprites 4) (the-as vector4w (-> obj sprites 1)) -92 15)
+    (cond
+      ((= s5-0 1)
+       (set! (-> obj sprites 4 color x) 0)
+       (set! (-> obj sprites 4 color y) 255)
+       (set! f30-0 (+ 2.0 f30-0))
+       )
+      ((= s5-0 2)
+       (set! (-> obj sprites 4 color y) 255)
+       (set! (-> obj sprites 4 color x) 255)
+       (set! f30-0 (+ 1.0 f30-0))
+       )
+      ((= s5-0 3)
+       (set! (-> obj sprites 4 color x) 255)
+       (set! (-> obj sprites 4 color y) 0)
+       0
+       )
+      (else
+        (set! f30-0 0.0)
+        )
+      )
+    (set! (-> obj sprites 4 scale-x) (* -7.25 f30-0))
+    )
+  (let ((f30-1 (* 0.01 (the float (-> obj values 2 current)))))
+    (set-as-offset-from! (-> obj sprites 3) (the-as vector4w (-> obj sprites 1)) -84 4)
+    (cond
+      ((< f30-1 0.5)
+       (set! (-> obj sprites 3 color x) 255)
+       (set! (-> obj sprites 3 color y) (the int (lerp 0.0 255.0 (* 2.0 f30-1))))
+       )
+      (else
+        (set! (-> obj sprites 3 color x) (the int (lerp 255.0 0.0 (* 2.0 (+ -0.5 f30-1)))))
+        (set! (-> obj sprites 3 color y) 255)
+        )
+      )
+    (set! (-> obj sprites 3 scale-x) (* -18.25 f30-1))
+    )
+  ((method-of-type hud draw) obj)
+  0
+  (none)
+  )
+
+;; definition for method 17 of type hud-widow
+;; WARN: Return type mismatch int vs none.
+(defmethod init-callback hud-widow ((obj hud-widow))
+  (set! (-> obj gui-id)
+        (add-process *gui-control* obj (gui-channel hud-middle-right) (gui-action hidden) (-> obj name) 81920.0 0)
+        )
+  (set! (-> obj values 0 target) 1)
+  (set! (-> obj values 1 target) 100)
+  (logior! (-> obj flags) (hud-flags show))
+  (set! (-> obj sprites 0 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x3b :page #x67a)))
+  (set! (-> obj sprites 0 flags) (the-as uint 4))
+  (set! (-> obj sprites 1 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x3c :page #x67a)))
+  (set! (-> obj sprites 1 flags) (the-as uint 4))
+  (set! (-> obj sprites 5 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x3d :page #x67a)))
+  (set! (-> obj sprites 5 scale-x) 0.5)
+  (set! (-> obj sprites 5 flags) (the-as uint 4))
+  (set! (-> obj sprites 6 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x3d :page #x67a)))
+  (set! (-> obj sprites 6 scale-x) 0.5)
+  (set! (-> obj sprites 6 flags) (the-as uint 4))
+  (set! (-> obj sprites 4 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x41 :page #x67a)))
+  (set! (-> obj sprites 4 scale-y) 3.25)
+  (set! (-> obj sprites 4 color z) 0)
+  (set! (-> obj sprites 4 flags) (the-as uint 4))
+  (set! (-> obj sprites 3 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x41 :page #x67a)))
+  (set! (-> obj sprites 3 scale-y) 1.5)
+  (set! (-> obj sprites 3 color z) 0)
+  (set! (-> obj sprites 3 flags) (the-as uint 4))
+  0
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/mars_tomb/widow-more-extras_REF.gc b/test/decompiler/reference/jak2/levels/mars_tomb/widow-more-extras_REF.gc
new file mode 100644
index 0000000000..676906f6f8
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/mars_tomb/widow-more-extras_REF.gc
@@ -0,0 +1,559 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type tomb-boss-debris
+(deftype tomb-boss-debris (process-drawable)
+  ((root-override collide-shape-moving         :offset        128)
+   (y-velocity    float                        :offset-assert 200)
+   (floor         float                        :offset-assert 204)
+   (sound-floor   float                        :offset-assert 208)
+   (rot           quaternion           :inline :offset-assert 224)
+   (look          int32                        :offset-assert 240)
+   )
+  :heap-base #x80
+  :method-count-assert 22
+  :size-assert         #xf4
+  :flag-assert         #x16008000f4
+  (:methods
+    (die () _type_ :state 20)
+    (idle () _type_ :state 21)
+    )
+  )
+
+;; definition for method 3 of type tomb-boss-debris
+(defmethod inspect tomb-boss-debris ((obj tomb-boss-debris))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Ty-velocity: ~f~%" (-> obj y-velocity))
+  (format #t "~2Tfloor: ~f~%" (-> obj floor))
+  (format #t "~2Tsound-floor: ~f~%" (-> obj sound-floor))
+  (format #t "~2Trot: #<quaternion @ #x~X>~%" (-> obj rot))
+  (format #t "~2Tlook: ~D~%" (-> obj look))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-tomb-boss-debris-a tomb-boss-debris tomb-boss-debris-a-lod0-jg tomb-boss-debris-a-idle-ja
+              ((tomb-boss-debris-a-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-tomb-boss-debris-b tomb-boss-debris tomb-boss-debris-b-lod0-jg tomb-boss-debris-b-idle-ja
+              ((tomb-boss-debris-b-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-tomb-boss-debris-c tomb-boss-debris tomb-boss-debris-c-lod0-jg tomb-boss-debris-c-idle-ja
+              ((tomb-boss-debris-c-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-tomb-boss-debris-d tomb-boss-debris tomb-boss-debris-d-lod0-jg tomb-boss-debris-d-idle-ja
+              ((tomb-boss-debris-d-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-tomb-boss-debris-e tomb-boss-debris tomb-boss-debris-e-lod0-jg tomb-boss-debris-e-idle-ja
+              ((tomb-boss-debris-e-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-tomb-boss-debris-f tomb-boss-debris tomb-boss-debris-f-lod0-jg tomb-boss-debris-f-idle-ja
+              ((tomb-boss-debris-f-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-tomb-boss-debris-g tomb-boss-debris tomb-boss-debris-g-lod0-jg tomb-boss-debris-g-idle-ja
+              ((tomb-boss-debris-g-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-tomb-boss-debris-h tomb-boss-debris tomb-boss-debris-h-lod0-jg tomb-boss-debris-h-idle-ja
+              ((tomb-boss-debris-h-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-tomb-boss-debris-i tomb-boss-debris tomb-boss-debris-i-lod0-jg tomb-boss-debris-i-idle-ja
+              ((tomb-boss-debris-i-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+;; failed to figure out what this is:
+(defstate die (tomb-boss-debris)
+  :virtual #t
+  :enter (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))
+    (none)
+    )
+  :code (behavior ()
+    (suspend)
+    (suspend)
+    0
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate idle (tomb-boss-debris)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('touched 'touch 'attack)
+       (let ((v1-2 (-> self look)))
+         (cond
+           ((or (zero? v1-2) (= v1-2 1) (= v1-2 2))
+            (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-8 s5-0)
+                      (a1-7 part-tracker-init)
+                      (a2-5 (-> *part-group-id-table* 734))
+                      (a3-2 5)
+                      (t0-0 #f)
+                      (t1-0 #f)
+                      (t2-0 #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-2)
+                   a0-8
+                   a1-7
+                   a2-5
+                   a3-2
+                   t0-0
+                   t1-0
+                   t2-0
+                   t3-0
+                   )
+                  )
+                (-> s5-0 ppointer)
+                )
+              )
+            (send-event proc 'debris-hit 1)
+            )
+           ((or (= v1-2 3) (= v1-2 4) (= v1-2 5))
+            (let ((s5-1 (get-process *default-dead-pool* part-tracker #x4000)))
+              (when s5-1
+                (let ((t9-5 (method-of-type part-tracker activate)))
+                  (t9-5
+                    (the-as part-tracker s5-1)
+                    *entity-pool*
+                    (symbol->string (-> part-tracker symbol))
+                    (the-as pointer #x70004000)
+                    )
+                  )
+                (let ((t9-6 run-function-in-process)
+                      (a0-16 s5-1)
+                      (a1-13 part-tracker-init)
+                      (a2-10 (-> *part-group-id-table* 735))
+                      (a3-4 5)
+                      (t0-1 #f)
+                      (t1-1 #f)
+                      (t2-1 #f)
+                      (t3-1 *launch-matrix*)
+                      )
+                  (set! (-> t3-1 trans quad) (-> self root-override trans quad))
+                  ((the-as (function object object object object object object object object none) t9-6)
+                   a0-16
+                   a1-13
+                   a2-10
+                   a3-4
+                   t0-1
+                   t1-1
+                   t2-1
+                   t3-1
+                   )
+                  )
+                (-> s5-1 ppointer)
+                )
+              )
+            (send-event proc 'debris-hit 2)
+            )
+           (else
+             (let ((s5-2 (get-process *default-dead-pool* part-tracker #x4000)))
+               (when s5-2
+                 (let ((t9-9 (method-of-type part-tracker activate)))
+                   (t9-9
+                     (the-as part-tracker s5-2)
+                     *entity-pool*
+                     (symbol->string (-> part-tracker symbol))
+                     (the-as pointer #x70004000)
+                     )
+                   )
+                 (let ((t9-10 run-function-in-process)
+                       (a0-21 s5-2)
+                       (a1-17 part-tracker-init)
+                       (a2-15 (-> *part-group-id-table* 736))
+                       (a3-6 5)
+                       (t0-2 #f)
+                       (t1-2 #f)
+                       (t2-2 #f)
+                       (t3-2 *launch-matrix*)
+                       )
+                   (set! (-> t3-2 trans quad) (-> self root-override trans quad))
+                   ((the-as (function object object object object object object object object none) t9-10)
+                    a0-21
+                    a1-17
+                    a2-15
+                    a3-6
+                    t0-2
+                    t1-2
+                    t2-2
+                    t3-2
+                    )
+                   )
+                 (-> s5-2 ppointer)
+                 )
+               )
+             (send-event proc 'debris-hit 3)
+             )
+           )
+         )
+       (go-virtual die)
+       )
+      )
+    )
+  :enter (behavior ()
+    (set! (-> self sound-floor) 81920.0)
+    (none)
+    )
+  :trans (behavior ()
+    (local-vars (sv-16 float))
+    (+! (-> self root-override trans y) (* (-> self y-velocity) (-> self clock time-adjust-ratio)))
+    (set! (-> self y-velocity)
+          (fmax -3686.4 (- (-> self y-velocity) (* 204.8 (-> self clock time-adjust-ratio))))
+          )
+    (if (< (-> self root-override trans y) (-> self floor))
+        (deactivate self)
+        )
+    (when (and (logtest? (-> self draw status) (draw-control-status on-screen))
+               (< (-> self root-override trans y) (+ (-> (camera-pos) y) (-> self sound-floor)))
+               )
+      (sound-play "wid-debris-fall")
+      (set! (-> self sound-floor) -4096000.0)
+      )
+    (quaternion-normalize! (quaternion*! (-> self root-override quat) (-> self rot) (-> self root-override quat)))
+    (let ((f30-1 (lerp-scale 1.0 0.0 (-> self root-override trans y) -368640.0 -442368.0)))
+      (when (< -442368.0 (-> self root-override trans y))
+        (let ((f28-0 (-> *part-id-table* 3266 init-specs 6 initial-valuef))
+              (f26-0 (-> *part-id-table* 3266 init-specs 6 random-rangef))
+              (f24-0 (-> *part-id-table* 3266 init-specs 7 initial-valuef))
+              (f22-0 (-> *part-id-table* 3266 init-specs 7 random-rangef))
+              (f20-0 (-> *part-id-table* 3266 init-specs 8 initial-valuef))
+              )
+          (set! sv-16 (-> *part-id-table* 3266 init-specs 8 random-rangef))
+          (set! (-> *part-id-table* 3266 init-specs 6 initial-valuef)
+                (* (-> *part-id-table* 3266 init-specs 6 initial-valuef) f30-1)
+                )
+          (set! (-> *part-id-table* 3266 init-specs 6 random-rangef)
+                (* (-> *part-id-table* 3266 init-specs 6 random-rangef) f30-1)
+                )
+          (set! (-> *part-id-table* 3266 init-specs 7 initial-valuef)
+                (* (-> *part-id-table* 3266 init-specs 7 initial-valuef) f30-1)
+                )
+          (set! (-> *part-id-table* 3266 init-specs 7 random-rangef)
+                (* (-> *part-id-table* 3266 init-specs 7 random-rangef) f30-1)
+                )
+          (set! (-> *part-id-table* 3266 init-specs 8 initial-valuef)
+                (* (-> *part-id-table* 3266 init-specs 8 initial-valuef) f30-1)
+                )
+          (set! (-> *part-id-table* 3266 init-specs 8 random-rangef)
+                (* (-> *part-id-table* 3266 init-specs 8 random-rangef) f30-1)
+                )
+          (spawn (-> self part) (-> self root-override trans))
+          (set! (-> *part-id-table* 3266 init-specs 6 initial-valuef) f28-0)
+          (set! (-> *part-id-table* 3266 init-specs 6 random-rangef) f26-0)
+          (set! (-> *part-id-table* 3266 init-specs 7 initial-valuef) f24-0)
+          (set! (-> *part-id-table* 3266 init-specs 7 random-rangef) f22-0)
+          (set! (-> *part-id-table* 3266 init-specs 8 initial-valuef) f20-0)
+          )
+        (set! (-> *part-id-table* 3266 init-specs 8 random-rangef) sv-16)
+        sv-16
+        )
+      (set-vector! (-> self draw color-mult) f30-1 f30-1 f30-1 1.0)
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior tomb-boss-debris) sleep-code)
+  :post (behavior ()
+    (transform-post)
+    (let ((a1-0 (new 'stack-no-clear 'overlaps-others-params)))
+      (set! (-> a1-0 options) (overlaps-others-options oo0))
+      (set! (-> a1-0 collide-with-filter) (the-as collide-spec -1))
+      (set! (-> a1-0 tlist) *touching-list*)
+      (find-overlapping-shapes (-> self root-override) a1-0)
+      )
+    (none)
+    )
+  )
+
+;; definition for function tomb-boss-debris-init-by-other
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defbehavior tomb-boss-debris-init-by-other tomb-boss-debris ((arg0 vector) (arg1 int))
+  (let ((s4-0 (new 'process 'collide-shape-moving self (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
+                                    generic-attack
+                                    lunge
+                                    flop
+                                    punch
+                                    spin
+                                    roll
+                                    uppercut
+                                    bonk
+                                    tube
+                                    vehicle
+                                    flut-attack
+                                    board
+                                    mech-punch
+                                    dark-punch
+                                    dark-giant
+                                    )
+          )
+    (let ((v1-7 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
+      (set! (-> v1-7 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-7 prim-core collide-with) (collide-spec jak bot enemy hit-by-others-list player-list))
+      (set! (-> v1-7 prim-core action) (collide-action solid))
+      (set-vector! (-> v1-7 local-sphere) 0.0 0.0 0.0 6144.0)
+      (set! (-> s4-0 total-prims) (the-as uint 1))
+      (set! (-> s4-0 root-prim) v1-7)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-10 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-10 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-10 prim-core collide-with))
+      )
+    (set! (-> s4-0 event-self) 'touched)
+    (set! (-> self root-override) s4-0)
+    )
+  (set! (-> self root-override trans quad) (-> arg0 quad))
+  (let ((v1-15 arg1))
+    (cond
+      ((zero? v1-15)
+       (initialize-skeleton
+         self
+         (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-debris-a" (the-as (pointer uint32) #f)))
+         (the-as pair 0)
+         )
+       )
+      ((= v1-15 1)
+       (initialize-skeleton
+         self
+         (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-debris-b" (the-as (pointer uint32) #f)))
+         (the-as pair 0)
+         )
+       )
+      ((= v1-15 2)
+       (set! (-> self root-override root-prim local-sphere w) 5120.0)
+       (initialize-skeleton
+         self
+         (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-debris-c" (the-as (pointer uint32) #f)))
+         (the-as pair 0)
+         )
+       )
+      ((= v1-15 3)
+       (set! (-> self root-override root-prim local-sphere w) 3276.8)
+       (initialize-skeleton
+         self
+         (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-debris-d" (the-as (pointer uint32) #f)))
+         (the-as pair 0)
+         )
+       )
+      ((= v1-15 4)
+       (set! (-> self root-override root-prim local-sphere w) 3276.8)
+       (initialize-skeleton
+         self
+         (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-debris-e" (the-as (pointer uint32) #f)))
+         (the-as pair 0)
+         )
+       )
+      ((= v1-15 5)
+       (set! (-> self root-override root-prim local-sphere w) 4096.0)
+       (initialize-skeleton
+         self
+         (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-debris-f" (the-as (pointer uint32) #f)))
+         (the-as pair 0)
+         )
+       )
+      ((= v1-15 6)
+       (set! (-> self root-override root-prim local-sphere w) 1638.4)
+       (initialize-skeleton
+         self
+         (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-debris-g" (the-as (pointer uint32) #f)))
+         (the-as pair 0)
+         )
+       )
+      ((= v1-15 7)
+       (set! (-> self root-override root-prim local-sphere w) 1638.4)
+       (initialize-skeleton
+         self
+         (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-debris-h" (the-as (pointer uint32) #f)))
+         (the-as pair 0)
+         )
+       )
+      (else
+        (set! (-> self root-override root-prim local-sphere w) 1638.4)
+        (initialize-skeleton
+          self
+          (the-as skeleton-group (art-group-get-by-name *level* "skel-tomb-boss-debris-i" (the-as (pointer uint32) #f)))
+          (the-as pair 0)
+          )
+        )
+      )
+    )
+  (set! (-> self look) arg1)
+  (set! (-> self y-velocity) -409.6)
+  (set! (-> self floor) (+ -655360.0 (-> self root-override trans y)))
+  (logclear! (-> self mask) (process-mask actor-pause))
+  (let ((f30-0 (rand-vu-float-range 0.0 65536.0))
+        (f28-0 (rand-vu-float-range 546.13336 1638.4))
+        )
+    (quaternion-axis-angle! (-> self rot) (sin f30-0) 0.0 (cos f30-0) f28-0)
+    )
+  (set! (-> self part) (create-launch-control (-> *part-group-id-table* 733) self))
+  (go-virtual idle)
+  (none)
+  )
+
+;; definition of type cave-in-master
+(deftype cave-in-master (process-drawable)
+  ((prev-points int32 100 :offset-assert 200)
+   )
+  :heap-base #x1e0
+  :method-count-assert 22
+  :size-assert         #x258
+  :flag-assert         #x1601e00258
+  (:methods
+    (idle () _type_ :state 20)
+    (wait () _type_ :state 21)
+    )
+  )
+
+;; definition for method 3 of type cave-in-master
+(defmethod inspect cave-in-master ((obj cave-in-master))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tprev-points[100] @ #x~X~%" (-> obj prev-points))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for function cavein-get-random-point
+;; INFO: Used lq/sq
+(defbehavior cavein-get-random-point cave-in-master ((arg0 vector))
+  (when (> (-> self path curve num-cverts) 0)
+    (let* ((s5-1 (min 100 (-> self path curve num-cverts)))
+           (v1-5 (rand-vu-int-count s5-1))
+           )
+      (while (> (-> self prev-points v1-5) 0)
+        (+! (-> self prev-points v1-5) -1)
+        (+! v1-5 1)
+        (if (>= v1-5 s5-1)
+            (set! v1-5 (- v1-5 s5-1))
+            )
+        )
+      (set! (-> self prev-points v1-5) 6)
+      (set! (-> arg0 quad) (-> self path curve cverts v1-5 quad))
+      )
+    )
+  arg0
+  )
+
+;; failed to figure out what this is:
+(defstate idle (cave-in-master)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :trans (behavior ()
+    (spawn (-> self part) (-> self root trans))
+    (when (>= (- (-> self clock frame-counter) (-> self state-time)) 0)
+      (let ((gp-0 (new 'stack-no-clear 'vector)))
+        (cavein-get-random-point gp-0)
+        (set! (-> gp-0 y) (+ 327680.0 (-> gp-0 y)))
+        (process-spawn tomb-boss-debris gp-0 (rand-vu-int-count 8) :to self)
+        )
+      (set! (-> self state-time)
+            (+ (-> self clock frame-counter) (the int (* 300.0 (rand-vu-float-range 0.1 0.5))))
+            )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior cave-in-master) sleep-code)
+  )
+
+;; failed to figure out what this is:
+(defstate wait (cave-in-master)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('start)
+       (go-virtual idle)
+       )
+      )
+    )
+  :code (the-as (function none :behavior cave-in-master) sleep-code)
+  )
+
+;; definition for method 11 of type cave-in-master
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! cave-in-master ((obj cave-in-master) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (set! (-> obj root) (new 'process 'trsqv))
+  (process-drawable-from-entity! obj arg0)
+  (set! (-> obj path) (new 'process 'path-control obj 'path 0.0 (the-as entity #f) #f))
+  (if (-> obj path)
+      (logior! (-> obj path flags) (path-control-flag display draw-line draw-point draw-text))
+      )
+  (set! (-> obj root trans y) (+ 327680.0 (-> obj root trans y)))
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (dotimes (v1-12 100)
+    (set! (-> obj prev-points v1-12) 0)
+    )
+  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 737) obj))
+  (go (method-of-object obj wait))
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/mars_tomb/widow2_REF.gc b/test/decompiler/reference/jak2/levels/mars_tomb/widow2_REF.gc
new file mode 100644
index 0000000000..10da52a3bb
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/mars_tomb/widow2_REF.gc
@@ -0,0 +1,405 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for method 37 of type widow-shot
+(defmethod deal-damage! widow-shot ((obj widow-shot) (arg0 process) (arg1 event-message-block))
+  "Constructs an [[attack-info]] according to the projectile's `options`"
+  (let ((t9-0 (method-of-type projectile deal-damage!)))
+    (when (t9-0 obj arg0 arg1)
+      (set! (-> obj hit-actor?) #t)
+      (if (= arg0 *target*)
+          (send-event (ppointer->process (-> obj parent)) 'shot-hit-target)
+          )
+      #t
+      )
+    )
+  )
+
+;; definition for method 44 of type widow
+;; INFO: Used lq/sq
+(defmethod widow-method-44 widow ((obj widow) (arg0 vector) (arg1 vector))
+  (let ((gp-0 (new 'stack-no-clear 'collide-query)))
+    (set! (-> gp-0 start-pos quad) (-> arg0 quad))
+    (vector-normalize-copy! (-> gp-0 move-dist) arg1 81920.0)
+    (let ((v1-1 gp-0))
+      (set! (-> v1-1 radius) 4096.0)
+      (set! (-> v1-1 collide-with) (collide-spec enemy hit-by-others-list))
+      (set! (-> v1-1 ignore-process0) obj)
+      (set! (-> v1-1 ignore-process1) #f)
+      (set! (-> v1-1 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+      (set! (-> v1-1 action-mask) (collide-action solid deadly))
+      )
+    (if (>= (fill-and-probe-using-line-sphere *collide-cache* gp-0) 0.0)
+        (return #f)
+        )
+    )
+  #t
+  )
+
+;; definition for method 45 of type widow
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch sound-id vs none.
+(defmethod widow-method-45 widow ((obj widow) (arg0 vector) (arg1 vector) (arg2 vector))
+  (let ((s5-0 (new 'stack-no-clear 'projectile-init-by-other-params)))
+    (let ((f30-0 (/ 2013265900.0 (vector-length arg2)))
+          (s3-0 (new 'stack-no-clear 'vector))
+          )
+      (set! (-> s5-0 ent) (-> obj entity))
+      (set! (-> s5-0 charge) 1.0)
+      (set! (-> s5-0 options) (projectile-options account-for-target-velocity))
+      (set! (-> s5-0 pos quad) (-> arg1 quad))
+      (set! (-> s5-0 notify-handle) (process->handle obj))
+      (set! (-> s5-0 owner-handle) (the-as handle #f))
+      (set! (-> s5-0 ignore-handle) (process->handle obj))
+      (let* ((v1-13 *game-info*)
+             (a0-12 (+ (-> v1-13 attack-id) 1))
+             )
+        (set! (-> v1-13 attack-id) a0-12)
+        (set! (-> s5-0 attack-id) a0-12)
+        )
+      (set! (-> s5-0 timeout) (new 'static 'handle :process #x4b0 :u64 #x4b0))
+      (vector-normalize-copy! (-> s5-0 vel) arg2 491520.0)
+      (let ((f30-1 (fmin 16384.0 f30-0)))
+        (set-vector! s3-0 (-> arg2 z) (-> arg2 y) (- (-> arg2 x)) 1.0)
+        (vector-normalize! s3-0 (rand-vu-float-range (- f30-1) f30-1))
+        (vector+! (-> s5-0 vel) (-> s5-0 vel) s3-0)
+        (vector-cross! s3-0 s3-0 (-> s5-0 vel))
+        (vector-normalize! s3-0 (rand-vu-float-range (- f30-1) f30-1))
+        )
+      (vector+! (-> s5-0 vel) (-> s5-0 vel) s3-0)
+      )
+    (spawn-projectile widow-shot s5-0 obj *default-dead-pool*)
+    )
+  (if arg0
+      (sound-play "widow-fire")
+      )
+  (none)
+  )
+
+;; definition for method 46 of type widow
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod widow-method-46 widow ((obj widow) (arg0 vector) (arg1 int))
+  (let ((s4-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data arg1)))
+        (s3-0 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> s3-0 quad) (-> obj node-list data arg1 bone transform vector 1 quad))
+    (if (widow-method-44 obj s4-0 s3-0)
+        (widow-method-45 obj arg0 s4-0 s3-0)
+        )
+    )
+  0
+  (none)
+  )
+
+;; definition for method 10 of type widow
+(defmethod deactivate widow ((obj widow))
+  (if (nonzero? (-> obj drill-spark-part))
+      (kill-and-free-particles (-> obj drill-spark-part))
+      )
+  (if (nonzero? (-> obj drill-spark-part-alt))
+      (kill-and-free-particles (-> obj drill-spark-part-alt))
+      )
+  (if (nonzero? (-> obj extract-stone-part))
+      (kill-and-free-particles (-> obj extract-stone-part))
+      )
+  (if (nonzero? (-> obj insert-stone-part))
+      (kill-and-free-particles (-> obj insert-stone-part))
+      )
+  (if (nonzero? (-> obj land-part))
+      (kill-and-free-particles (-> obj land-part))
+      )
+  (if (nonzero? (-> obj green-charge-part))
+      (kill-and-free-particles (-> obj green-charge-part))
+      )
+  (if (nonzero? (-> obj green-fire-part))
+      (kill-and-free-particles (-> obj green-fire-part))
+      )
+  (if (-> obj drill-sound-playing)
+      (sound-stop (the-as sound-id (-> obj drill-sound)))
+      )
+  (if (-> obj drill-sweeten-sound-playing)
+      (sound-stop (the-as sound-id (-> obj drill-sweeten-sound)))
+      )
+  (if (-> obj hover-sound-playing)
+      (sound-stop (the-as sound-id (-> obj hover-sound)))
+      )
+  (if (-> obj shake-sound-playing)
+      (sound-stop (the-as sound-id (-> obj shake-sound)))
+      )
+  ((method-of-type process-drawable deactivate) obj)
+  (none)
+  )
+
+;; definition for method 7 of type widow
+;; WARN: Return type mismatch process-drawable vs widow.
+(defmethod relocate widow ((obj widow) (arg0 int))
+  (if (nonzero? (-> obj left-cover-jm))
+      (&+! (-> obj left-cover-jm) arg0)
+      )
+  (if (nonzero? (-> obj right-cover-jm))
+      (&+! (-> obj right-cover-jm) arg0)
+      )
+  (if (nonzero? (-> obj left-drill-jm))
+      (&+! (-> obj left-drill-jm) arg0)
+      )
+  (if (nonzero? (-> obj right-drill-jm))
+      (&+! (-> obj right-drill-jm) arg0)
+      )
+  (if (nonzero? (-> obj drill-spark-part))
+      (&+! (-> obj drill-spark-part) arg0)
+      )
+  (if (nonzero? (-> obj drill-spark-part-alt))
+      (&+! (-> obj drill-spark-part-alt) arg0)
+      )
+  (if (nonzero? (-> obj extract-stone-part))
+      (&+! (-> obj extract-stone-part) arg0)
+      )
+  (if (nonzero? (-> obj insert-stone-part))
+      (&+! (-> obj insert-stone-part) arg0)
+      )
+  (if (nonzero? (-> obj land-part))
+      (&+! (-> obj land-part) arg0)
+      )
+  (if (nonzero? (-> obj green-charge-part))
+      (&+! (-> obj green-charge-part) arg0)
+      )
+  (if (nonzero? (-> obj green-fire-part))
+      (&+! (-> obj green-fire-part) arg0)
+      )
+  (dotimes (v1-44 5)
+    (if (nonzero? (-> obj lightning v1-44))
+        (&+! (-> obj lightning v1-44) arg0)
+        )
+    )
+  (the-as widow ((method-of-type process-drawable relocate) obj arg0))
+  )
+
+;; definition for method 11 of type widow
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! widow ((obj widow) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (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
+            generic-attack
+            lunge
+            flop
+            punch
+            spin
+            roll
+            uppercut
+            bonk
+            tube
+            vehicle
+            flut-attack
+            board
+            mech-punch
+            dark-punch
+            dark-giant
+            )
+          )
+    (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 1) 0)))
+      (set! (-> s4-0 total-prims) (the-as uint 2))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec enemy))
+      (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 0.0 9216.0 36864.0)
+      (set! (-> s4-0 root-prim) s3-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 enemy))
+      (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 32768.0)
+      )
+    (set! (-> s4-0 nav-radius) 8192.0)
+    (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! (-> obj root) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-widow" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj skel generate-frame-function) create-interpolated2-joint-animation-frame)
+  (setup-masks (-> obj draw) 0 126)
+  (set! (-> obj root pause-adjust-distance) 245760.0)
+  (dotimes (v1-26 8)
+    (set! (-> obj catwalk v1-26) (the-as handle #f))
+    )
+  (let ((s4-2 (-> obj entity extra perm)))
+    (logior! (-> s4-2 status) (entity-perm-status bit-5))
+    0
+    (let ((s3-2 (new 'stack-no-clear 'vector)))
+      (set! (-> s3-2 quad) (-> arg0 extra trans quad))
+      (set! (-> s3-2 y) (+ -32768.0 (-> s3-2 y)))
+      (set! (-> s3-2 z) (+ 42475.52 (-> s3-2 z)))
+      (dotimes (s5-1 8)
+        (cond
+          ((not (logtest? (the-as int (-> s4-2 user-object 1)) (ash 1 s5-1)))
+           (set! (-> obj catwalk s5-1) (ppointer->handle (process-spawn tomb-boss-catwalk s3-2 s5-1 :to obj)))
+           (if (not (handle->process (-> obj catwalk s5-1)))
+               (format 0 "catwalk ~D failed to spawn~%" s5-1)
+               )
+           )
+          (else
+            (send-event (handle->process (-> obj catwalk 0)) 'catwalk-hit s5-1)
+            )
+          )
+        )
+      )
+    )
+  (dotimes (v1-62 8)
+    (set! (-> obj bomb v1-62) (the-as handle #f))
+    )
+  (dotimes (v1-65 2)
+    (set! (-> obj ammos v1-65) (the-as handle #f))
+    (set! (-> obj ammo-timers v1-65) 0)
+    )
+  (set! (-> obj attack-from-high-deg) #f)
+  (set! (-> obj which-gun) 0)
+  (set! (-> obj which-pod) 0)
+  (set! (-> obj bomb-hits) 0)
+  (set! (-> obj flying) #f)
+  (set! (-> obj previous-anim) 0)
+  (set! (-> obj circle-center quad) (-> obj root trans quad))
+  (set! (-> obj circle-center z) (+ 40960.0 (-> obj circle-center z)))
+  (init (-> obj theta) 0.0 0.01 91.022224 0.9)
+  (init (-> obj tilt) 0.0 0.01 91.022224 0.9)
+  (set! (-> obj left-cover-jm) (new 'process 'joint-mod (joint-mod-mode joint-set*) obj 90))
+  (set! (-> obj right-cover-jm) (new 'process 'joint-mod (joint-mod-mode joint-set*) obj 91))
+  (widow-float-seeker-method-9 (-> obj left-cover-angle) 0.0 0.01 0.1 0.9 0.25)
+  (widow-float-seeker-method-9 (-> obj right-cover-angle) 0.0 0.01 0.1 0.9 0.25)
+  (set! (-> obj left-drill-jm) (new 'process 'joint-mod (joint-mod-mode joint-set*) obj 11))
+  (set! (-> obj right-drill-jm) (new 'process 'joint-mod (joint-mod-mode joint-set*) obj 44))
+  (init (-> obj drill-speed) 0.0 0.01 0.1 0.9)
+  (let ((s5-2 (new 'stack-no-clear 'vector)))
+    (set! (-> s5-2 quad) (-> obj root trans quad))
+    (set! (-> obj baron) (process-spawn
+                           manipy
+                           :init manipy-init
+                           s5-2
+                           (-> obj entity)
+                           (art-group-get-by-name *level* "skel-baron" (the-as (pointer uint32) #f))
+                           #f
+                           0
+                           :to obj
+                           )
+          )
+    )
+  (logior! (-> obj baron 0 draw global-effect) (draw-control-global-effect disable-envmap))
+  (send-event (ppointer->process (-> obj baron)) 'anim-mode 'clone-anim)
+  (set! (-> obj baron 0 draw light-index) (mod (-> obj draw light-index) (the-as uint 10)))
+  (let ((v1-106 (-> obj baron)))
+    (if v1-106
+        (logclear! (-> v1-106 0 mask) (process-mask actor-pause))
+        )
+    )
+  (set! (-> obj pod) (ppointer->handle (process-spawn baron-pod (-> obj root trans) :to obj)))
+  (set! (-> obj heart) (the-as handle #f))
+  (set! (-> obj drill-spark-part) (create-launch-control (-> *part-group-id-table* 713) obj))
+  (set! (-> obj drill-spark-part-alt) (create-launch-control (-> *part-group-id-table* 714) obj))
+  (set! (-> obj extract-stone-time) 0)
+  (set! (-> obj extract-stone-part) (create-launch-control (-> *part-group-id-table* 715) obj))
+  (set! (-> obj insert-stone-time) 0)
+  (set! (-> obj insert-stone-part) (create-launch-control (-> *part-group-id-table* 716) obj))
+  (set! (-> obj land-part) (create-launch-control (-> *part-group-id-table* 730) obj))
+  (set! (-> obj green-charge-part) (create-launch-control (-> *part-group-id-table* 731) obj))
+  (set! (-> obj green-fire-part) (create-launch-control (-> *part-group-id-table* 732) obj))
+  (add-connection *part-engine* obj 73 obj 3251 (new 'static 'vector :w 819200.0))
+  (add-connection *part-engine* obj 77 obj 3251 (new 'static 'vector :w 819200.0))
+  (add-connection *part-engine* obj 78 obj 3251 (new 'static 'vector :w 819200.0))
+  (dotimes (s5-4 5)
+    (set! (-> obj lightning s5-4) (new
+                                    'process
+                                    'lightning-control
+                                    (new 'static 'lightning-spec
+                                      :name #f
+                                      :flags (lightning-spec-flags lsf0)
+                                      :start-color (new 'static 'rgba :r #x80 :g #x80 :b #x80 :a #x80)
+                                      :end-color (new 'static 'rgba :r #x80 :g #x80 :b #x80 :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 #x7 :page #x8c7)
+                                      :reduction 0.4
+                                      :num-points 48
+                                      :box-size 57344.0
+                                      :merge-factor 0.5
+                                      :merge-count 2
+                                      :radius 9216.0
+                                      :duration -1.0
+                                      :sound #f
+                                      )
+                                    obj
+                                    0.0
+                                    )
+          )
+    (let ((v1-148 (-> obj lightning s5-4))
+          (a0-97 0)
+          )
+      (let ((a1-48 (!= a0-97 (-> v1-148 state mode))))
+        (case a0-97
+          ((3)
+           (if a1-48
+               (set! (-> v1-148 state counter) 0.0)
+               )
+           )
+          ((1)
+           (set! (-> v1-148 state start-color) (-> v1-148 spec start-color))
+           (set! (-> v1-148 state end-color) (-> v1-148 spec end-color))
+           )
+          )
+        )
+      (set! (-> v1-148 state mode) (the-as lightning-mode a0-97))
+      )
+    )
+  (set! (-> obj catwalk-sound) (the-as uint (new-sound-id)))
+  (set! (-> obj drill-sound) (the-as uint (new-sound-id)))
+  (set! (-> obj drill-sound-playing) #f)
+  (set! (-> obj drill-sweeten-sound) (the-as uint (new-sound-id)))
+  (set! (-> obj drill-sweeten-sound-playing) #f)
+  (set! (-> obj hover-sound) (the-as uint (new-sound-id)))
+  (set! (-> obj hover-sound-playing) #f)
+  (set! (-> obj shake-sound) (the-as uint (new-sound-id)))
+  (set! (-> obj shake-sound-playing) #f)
+  (set! (-> obj hud) (the-as handle #f))
+  (set! (-> obj last-want-stone-talker) 0)
+  (set! (-> obj last-general-flying-talker) 0)
+  (set! (-> obj last-launch-droids-talker) 0)
+  (set! (-> obj last-launch-bombs-talker) 0)
+  (set! (-> obj last-shoot-gun-talker) 0)
+  (set! (-> obj last-stone-charge-up-talker) 0)
+  (set! (-> obj last-after-stone-shot-talker) 0)
+  (set! (-> obj last-leave-perch-talker) 0)
+  (set! (-> obj last-damaged-talker) 0)
+  (set! (-> obj kicked-bombs) 0)
+  (set! (-> obj launch-stages-completed) 0)
+  (set! (-> obj current-shoot-stage) 0)
+  (set! (-> obj last-gun-hit-stage) 0)
+  (set! (-> obj gun-hits) 0)
+  (set! (-> obj last-attack-id) (the-as uint 0))
+  (if (task-node-closed? (game-task-node tomb-boss-resolution))
+      (go (method-of-object obj beaten))
+      (go (method-of-object obj hidden))
+      )
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/nest/flying-spider_REF.gc b/test/decompiler/reference/jak2/levels/nest/flying-spider_REF.gc
new file mode 100644
index 0000000000..85fac70868
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/nest/flying-spider_REF.gc
@@ -0,0 +1,959 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type flying-spider-shot
+(deftype flying-spider-shot (metalhead-shot)
+  ()
+  :heap-base #x170
+  :method-count-assert 40
+  :size-assert         #x1f0
+  :flag-assert         #x28017001f0
+  )
+
+;; definition for method 3 of type flying-spider-shot
+(defmethod inspect flying-spider-shot ((obj flying-spider-shot))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type metalhead-shot inspect)))
+    (t9-0 obj)
+    )
+  (label cfg-4)
+  obj
+  )
+
+;; definition for method 28 of type flying-spider-shot
+(defmethod play-impact-sound flying-spider-shot ((obj flying-spider-shot) (arg0 projectile-options))
+  (if (zero? arg0)
+      (sound-play "fly-spider-shot")
+      ((the-as (function projectile projectile-options sound-id) (find-parent-method flying-spider-shot 28))
+       obj
+       arg0
+       )
+      )
+  )
+
+;; definition for function spawn-flying-spider-projectile
+;; INFO: Used lq/sq
+(defun spawn-flying-spider-projectile ((arg0 flying-spider) (arg1 vector) (arg2 vector) (arg3 float))
+  (let ((gp-0 (new 'stack-no-clear 'projectile-init-by-other-params)))
+    (let ((v1-1 (vector-! (new 'stack-no-clear 'vector) arg2 arg1)))
+      (set! (-> gp-0 ent) (-> arg0 entity))
+      (set! (-> gp-0 charge) 1.0)
+      (set! (-> gp-0 options) (projectile-options))
+      (set! (-> gp-0 notify-handle) (process->handle arg0))
+      (set! (-> gp-0 owner-handle) (the-as handle #f))
+      (set! (-> gp-0 ignore-handle) (process->handle arg0))
+      (let* ((a0-10 *game-info*)
+             (a2-11 (+ (-> a0-10 attack-id) 1))
+             )
+        (set! (-> a0-10 attack-id) a2-11)
+        (set! (-> gp-0 attack-id) a2-11)
+        )
+      (set! (-> gp-0 timeout) (new 'static 'handle :process #x4b0 :u64 #x4b0))
+      (set! (-> gp-0 pos quad) (-> arg1 quad))
+      (vector-normalize-copy! (-> gp-0 vel) v1-1 arg3)
+      )
+    (spawn-projectile flying-spider-shot gp-0 arg0 *default-dead-pool*)
+    )
+  )
+
+;; definition of type flying-spider
+(deftype flying-spider (nav-enemy)
+  ((my-up-vector vector     :inline :offset-assert 608)
+   (gspot-normal vector     :inline :offset-assert 624)
+   (gspot-timer  time-frame         :offset-assert 640)
+   (focus-dir    uint16             :offset-assert 648)
+   (path-u       float              :offset-assert 652)
+   (path-du      float              :offset-assert 656)
+   )
+  :heap-base #x220
+  :method-count-assert 183
+  :size-assert         #x294
+  :flag-assert         #xb702200294
+  (:methods
+    (ambush-falling () _type_ :state 178)
+    (attack () _type_ :state 179)
+    (attack-fire () _type_ :state 180)
+    (turn-to-focus () _type_ :state 181)
+    (flying-spider-method-182 (_type_ vector) none 182)
+    )
+  )
+
+;; definition for method 3 of type flying-spider
+(defmethod inspect flying-spider ((obj flying-spider))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type nav-enemy inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tmy-up-vector: #<vector @ #x~X>~%" (-> obj my-up-vector))
+  (format #t "~2Tgspot-normal: #<vector @ #x~X>~%" (-> obj gspot-normal))
+  (format #t "~2Tgspot-timer: ~D~%" (-> obj gspot-timer))
+  (format #t "~2Tfocus-dir: ~D~%" (-> obj focus-dir))
+  (format #t "~2Tpath-u: ~f~%" (-> obj path-u))
+  (format #t "~2Tpath-du: ~f~%" (-> obj path-du))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-flying-spider flying-spider flying-spider-lod0-jg flying-spider-walk0-ja
+              ((flying-spider-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 1.5 0 6)
+              :shadow flying-spider-shadow-mg
+              )
+
+;; definition for symbol *flying-spider-nav-enemy-info*, type nav-enemy-info
+(define *flying-spider-nav-enemy-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #f
+    :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 idle-control-frame 4
+      (new 'static 'idle-control-frame :command (ic-cmd push) :param0 #x1e)
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x5 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 5
+    :notice-anim 5
+    :hostile-anim 9
+    :hit-anim 5
+    :knocked-anim 12
+    :knocked-land-anim 13
+    :die-anim 18
+    :die-falling-anim 18
+    :victory-anim 10
+    :jump-wind-up-anim -1
+    :jump-in-air-anim -1
+    :jump-land-anim -1
+    :neck-joint 25
+    :look-at-joint 27
+    :bullseye-joint 27
+    :sound-hit (static-sound-name "fly-spider-hit")
+    :sound-die (static-sound-name "fly-spider-die")
+    :notice-distance (meters 50)
+    :notice-distance-delta (meters 10)
+    :proximity-notice-distance (meters 12.5)
+    :default-hit-points 16
+    :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
+    :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher)
+    :jump-height-min (meters 3)
+    :jump-height-factor 0.5
+    :shadow-size (meters 1)
+    :shadow-max-y (meters 1)
+    :shadow-min-y (meters -1)
+    :shadow-locus-dist (meters 150)
+    :gem-joint 27
+    :gem-seg #x2
+    :gem-no-seg #x4
+    :gem-offset (new 'static 'sphere :y 2048.0 :z 3112.96 :r 327680.0)
+    :callback-info #f
+    :use-momentum #f
+    :use-frustration #f
+    :use-stop-chase #f
+    :use-circling #f
+    :use-pacing #f
+    :walk-anim 9
+    :turn-anim 5
+    :run-anim 9
+    :taunt-anim -1
+    :run-travel-speed (meters 6)
+    :run-acceleration (meters 1)
+    :run-turning-acceleration (meters 10)
+    :walk-travel-speed (meters 3)
+    :walk-acceleration (meters 1)
+    :walk-turning-acceleration (meters 5)
+    :maximum-rotation-rate (degrees 112.5)
+    :notice-nav-radius (meters 20)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :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! (-> *flying-spider-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+;; failed to figure out what this is:
+(defstate active (flying-spider)
+  :virtual #t
+  :code (behavior ()
+    (until #f
+      (ja-no-eval :group! flying-spider-idle0-ja
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim flying-spider-idle0-ja) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior flying-spider) nav-enemy-simple-post)
+  )
+
+;; failed to figure out what this is:
+(defstate ambush (flying-spider)
+  :virtual #t
+  :enter (behavior ()
+    (when (logtest? (-> self enemy-flags) (enemy-flag auto-reset-penetrate))
+      (logclear! (-> self enemy-flags) (enemy-flag auto-reset-penetrate))
+      (let ((gp-0 (-> self on-notice)))
+        (if gp-0
+            (eval!
+              (new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans))
+              (the-as pair gp-0)
+              )
+            )
+        )
+      )
+    (logclear! (-> self enemy-flags) (enemy-flag lock-focus death-start))
+    (set! (-> self path-du) (get-rand-float-range self 0.2 0.5))
+    (set-vector! (-> self root-override2 scale) 0.0 0.0 0.0 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (if (= (-> self path-u) 1.0)
+        (go-virtual ambush-falling)
+        )
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 0)
+    (until #f
+      (ja-no-eval :group! flying-spider-idle-flying-ja
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim flying-spider-idle-flying-ja) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (get-point-at-percent-along-path! (-> self path) (-> self root-override2 trans) (-> self path-u) 'interp)
+    (set! (-> self path-u) (seek-ease
+                             (-> self path-u)
+                             1.0
+                             (* (-> self path-du) (-> self clock seconds-per-frame))
+                             0.2
+                             (* 0.04 (-> self clock seconds-per-frame))
+                             )
+          )
+    (let ((f0-7 (-> self path-u)))
+      (set-vector! (-> self root-override2 scale) f0-7 f0-7 f0-7 0.0)
+      )
+    (let ((a1-3 (displacement-between-points-at-percent-normalized!
+                  (-> self path)
+                  (new 'stack-no-clear 'vector)
+                  (fmin 1.0 (+ 0.2 (-> self path-u)))
+                  )
+                )
+          )
+      (forward-up-nopitch->quaternion (-> self root-override2 quat) a1-3 *y-vector*)
+      )
+    (nav-enemy-simple-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate ambush-falling (flying-spider)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior flying-spider) enemy-event-handler)
+  :code (behavior ()
+    (ja-no-eval :group! flying-spider-drop-down-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim flying-spider-drop-down-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (until (logtest? (-> self root-override2 status) (collide-status on-ground))
+      (suspend)
+      )
+    (let ((s5-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat)))
+          (gp-0 (new 'stack-no-clear 'quaternion))
+          )
+      (set! (-> s5-0 y) 0.0)
+      (vector-xz-normalize! s5-0 1.0)
+      (forward-up-nopitch->quaternion gp-0 s5-0 *y-vector*)
+      (ja-no-eval :group! flying-spider-drop-down-land-ja
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim flying-spider-drop-down-land-ja) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (quaternion-slerp!
+          (-> self root-override2 quat)
+          (-> self root-override2 quat)
+          gp-0
+          (* 2.0 (-> self clock seconds-per-frame))
+          )
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    (enemy-method-127 self 40960.0 40960.0 #t (collide-spec backgnd))
+    (go-hostile self)
+    (none)
+    )
+  :post (behavior ()
+    (let ((a1-0 (new 'stack-no-clear 'collide-query)))
+      (enemy-method-125 self a1-0 (-> self root-override2 root-prim prim-core collide-with) 8192.0 81920.0 1024.0)
+      )
+    (flying-spider-method-182
+      self
+      (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat))
+      )
+    (nav-enemy-falling-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate hostile (flying-spider)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior flying-spider) enemy-event-handler)
+  :trans (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy hostile) trans)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (let ((a0-1 (handle->process (-> self focus handle))))
+      (when (and a0-1
+                 (< (vector-vector-distance (get-trans (the-as process-focusable a0-1) 0) (-> self root-override2 trans))
+                    81920.0
+                    )
+                 )
+        (if (not (enemy-method-96 self 5461.3335 #t))
+            (go-virtual turn-to-focus)
+            (go-virtual attack)
+            )
+        )
+      )
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate turn-to-focus (flying-spider)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior flying-spider) enemy-event-handler)
+  :enter (behavior ()
+    (let ((v1-0 self))
+      (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-0 enemy-flags))))
+      )
+    0
+    (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
+    (none)
+    )
+  :trans (behavior ()
+    (if (>= 2 (the-as int (-> self focus aware)))
+        (go-stare self)
+        )
+    (let ((s3-0 (handle->process (-> self focus handle))))
+      (cond
+        (s3-0
+          (let ((gp-0 (vector-x-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat)))
+                (s4-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat)))
+                (s5-1 (vector-!
+                        (new 'stack-no-clear 'vector)
+                        (get-trans (the-as process-focusable s3-0) 0)
+                        (-> self root-override2 trans)
+                        )
+                      )
+                )
+            (set! (-> gp-0 y) 0.0)
+            (set! (-> s4-0 y) 0.0)
+            (set! (-> s5-1 y) 0.0)
+            (vector-normalize! gp-0 1.0)
+            (vector-normalize! s4-0 1.0)
+            (vector-normalize! s5-1 1.0)
+            (cond
+              ((< (cos 910.2222) (vector-dot s5-1 s4-0))
+               (set! (-> self focus-dir) (the-as uint 0))
+               0
+               )
+              ((< 0.0 (vector-dot s5-1 gp-0))
+               (set! (-> self focus-dir) (the-as uint 1))
+               )
+              (else
+                (set! (-> self focus-dir) (the-as uint 2))
+                )
+              )
+            )
+          )
+        (else
+          (go-stare self)
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (when (= (-> self focus-dir) 1)
+        (let ((v1-4 (ja-group)))
+          (if (not (and v1-4 (= v1-4 flying-spider-turn-left-180-ja)))
+              (ja-channel-push! 1 (seconds 0.15))
+              )
+          )
+        (ja-no-eval :group! flying-spider-turn-left-180-ja :num! (loop!) :frame-num 0.0)
+        (while (= (-> self focus-dir) 1)
+          (suspend)
+          (ja :num! (loop!))
+          )
+        )
+      (when (= (-> self focus-dir) 2)
+        (let ((v1-28 (ja-group)))
+          (if (not (and v1-28 (= v1-28 flying-spider-turn-right-180-ja)))
+              (ja-channel-push! 1 (seconds 0.15))
+              )
+          )
+        (ja-no-eval :group! flying-spider-turn-right-180-ja :num! (loop!) :frame-num 0.0)
+        (while (= (-> self focus-dir) 2)
+          (suspend)
+          (ja :num! (loop!))
+          )
+        )
+      (if (zero? (-> self focus-dir))
+          (go-hostile self)
+          )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (flying-spider-method-182
+      self
+      (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat))
+      )
+    (nav-enemy-face-focus-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate stare (flying-spider)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy stare) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (let ((v1-4 self))
+      (set! (-> v1-4 enemy-flags) (the-as enemy-flag (logclear (-> v1-4 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate attack (flying-spider)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior flying-spider) enemy-event-handler)
+  :enter (behavior ()
+    (let ((v1-0 self))
+      (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logclear (-> v1-0 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (none)
+    )
+  :trans (behavior ()
+    (let ((a0-1 (enemy-method-107 self)))
+      (cond
+        ((or (not a0-1) (>= 2 (the-as int (-> self focus aware))))
+         (go-stare self)
+         )
+        ((< 98304.0 (vector-vector-distance (get-trans a0-1 0) (-> self root-override2 trans)))
+         (go-hostile self)
+         )
+        ((not (enemy-method-96 self 5461.3335 #t))
+         (go-virtual turn-to-focus)
+         )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (ja-channel-push! 1 (seconds 0.15))
+      (ja-no-eval :group! flying-spider-idle0-ja
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim flying-spider-idle0-ja) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      (if (enemy-method-107 self)
+          (go-virtual attack-fire)
+          )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-simple-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate attack-fire (flying-spider)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('event-attack-l)
+       (let* ((s5-0 (-> self node-list data 30))
+              (gp-0 (vector<-cspace! (new 'stack-no-clear 'vector) s5-0))
+              (a0-3 (vector-normalize-copy! (new 'stack-no-clear 'vector) (-> s5-0 bone transform vector 2) 163840.0))
+              (a2-3 (vector+! (new 'stack-no-clear 'vector) gp-0 a0-3))
+              )
+         (spawn-flying-spider-projectile self gp-0 a2-3 532480.0)
+         )
+       )
+      (('event-attack-r)
+       (let* ((s5-1 (-> self node-list data 35))
+              (gp-1 (vector<-cspace! (new 'stack-no-clear 'vector) s5-1))
+              (a0-7 (vector-normalize-copy! (new 'stack-no-clear 'vector) (-> s5-1 bone transform vector 2) -163840.0))
+              (a2-6 (vector+! (new 'stack-no-clear 'vector) gp-1 a0-7))
+              )
+         (spawn-flying-spider-projectile self gp-1 a2-6 532480.0)
+         )
+       )
+      (else
+        (enemy-event-handler proc arg1 event-type event)
+        )
+      )
+    )
+  :enter (behavior ()
+    (let ((v1-0 self))
+      (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logclear (-> v1-0 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.1))
+    (ja-no-eval :group! flying-spider-shoot-start-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim flying-spider-shoot-start-ja) frames num-frames) -1)) 2.0)
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! max 2.0))
+      )
+    (ja-no-eval :group! flying-spider-shoot-right-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim flying-spider-shoot-right-ja) frames num-frames) -1)) 2.0)
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! max 2.0))
+      )
+    (ja-no-eval :group! flying-spider-shoot-left-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim flying-spider-shoot-left-ja) frames num-frames) -1)) 2.0)
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! max 2.0))
+      )
+    (ja-no-eval :group! flying-spider-shoot-stop-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim flying-spider-shoot-stop-ja) frames num-frames) -1)) 2.0)
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! max 2.0))
+      )
+    (go-virtual attack)
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-simple-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate die (flying-spider)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior flying-spider) enemy-event-handler)
+  :enter (behavior ()
+    (enemy-method-132 self)
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self hit-points) 0)
+    (enemy-method-103 self)
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.075))
+    (let ((f30-0 (get-rand-float-range self 0.8 1.2)))
+      (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override die-anim))
+                  :num! (seek!
+                    (the float
+                         (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override die-anim)))
+                                frames
+                                num-frames
+                                )
+                            -1
+                            )
+                         )
+                    f30-0
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      )
+    (send-event self 'death-end)
+    (let ((v1-34 (-> self root-override2 root-prim)))
+      (set! (-> v1-34 prim-core collide-as) (collide-spec))
+      (set! (-> v1-34 prim-core collide-with) (collide-spec))
+      )
+    0
+    (while (-> self child)
+      (suspend)
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  :post (the-as (function none :behavior flying-spider) enemy-simple-post)
+  )
+
+;; definition for method 74 of type flying-spider
+(defmethod enemy-method-74 flying-spider ((obj flying-spider) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (case arg2
+    (('hit 'hit-knocked)
+     (logclear! (-> obj mask) (process-mask actor-pause))
+     (logclear! (-> obj focus-status) (focus-status dangerous))
+     (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice))
+     (logior! (-> obj enemy-flags) (enemy-flag chase-startup))
+     (logior! (-> obj focus-status) (focus-status hit))
+     (if (zero? (-> obj hit-points))
+         (logior! (-> obj focus-status) (focus-status dead))
+         )
+     (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup))
+     (enemy-method-62 obj)
+     (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
+     (process-contact-action arg0)
+     (send-event arg0 'get-attack-count 1)
+     (cond
+       ((zero? (-> obj hit-points))
+        (let ((s5-1 (-> obj incoming knocked-type)))
+          (cond
+            ((and (= s5-1 (knocked-type knocked-type-4))
+                  (not (and (-> obj next-state) (let ((v1-32 (-> obj next-state name)))
+                                                  (or (= v1-32 'knocked) (= v1-32 'jump) (= v1-32 'jump-land))
+                                                  )
+                            )
+                       )
+                  (zero? (get-rand-int obj 3))
+                  (let ((f0-0 (vector-vector-distance-squared (-> obj root-override2 trans) (target-pos 0)))
+                        (f1-0 32768.0)
+                        )
+                    (>= f0-0 (* f1-0 f1-0))
+                    )
+                  )
+             (enemy-method-73 obj)
+             )
+            ((or (= s5-1 (knocked-type knocked-type-4)) (= s5-1 (knocked-type knocked-type-6)))
+             (set! (-> obj incoming knocked-type) (knocked-type knocked-type-0))
+             (go (method-of-object obj knocked))
+             )
+            (else
+              (go (method-of-object obj knocked))
+              )
+            )
+          )
+        )
+       (else
+         (go (method-of-object obj knocked))
+         )
+       )
+     #t
+     )
+    (('death-start)
+     (let ((v1-52 (-> obj root-override2 root-prim)))
+       (set! (-> v1-52 prim-core collide-as) (collide-spec))
+       (set! (-> v1-52 prim-core collide-with) (collide-spec))
+       )
+     0
+     ((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 55 of type flying-spider
+(defmethod enemy-method-55 flying-spider ((obj flying-spider))
+  ((method-of-type nav-enemy enemy-method-55) obj)
+  (none)
+  )
+
+;; definition for method 125 of type flying-spider
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch symbol vs pat-surface.
+(defmethod enemy-method-125 flying-spider ((obj flying-spider) (arg0 collide-query) (arg1 collide-spec) (arg2 float) (arg3 float) (arg4 float))
+  (with-pp
+    (the-as
+      pat-surface
+      (when (find-ground (-> obj root-override2) arg0 arg1 arg2 arg3 arg4)
+        (set! (-> obj root-override2 ground-pat) (-> arg0 best-other-tri pat))
+        (when (>= (- (-> pp clock frame-counter) (-> obj gspot-timer)) (seconds 0.2))
+          (let ((a1-2 (new 'stack-no-clear 'collide-query)))
+            (set! (-> a1-2 start-pos quad) (-> obj root-override2 gspot-pos quad))
+            (set! (-> a1-2 start-pos y) (+ 2048.0 (-> a1-2 start-pos y)))
+            (set-vector! (-> a1-2 move-dist) 0.0 -6144.0 0.0 0.0)
+            (let ((v1-10 a1-2))
+              (set! (-> v1-10 radius) 4915.2)
+              (set! (-> v1-10 collide-with) arg1)
+              (set! (-> v1-10 ignore-process0) obj)
+              (set! (-> v1-10 ignore-process1) #f)
+              (set! (-> v1-10 ignore-pat) (-> obj root-override2 pat-ignore-mask))
+              (set! (-> v1-10 action-mask) (collide-action solid))
+              )
+            (fill-using-line-sphere *collide-cache* a1-2)
+            )
+          (let ((s5-1 (new 'stack-no-clear 'vector)))
+            (vector-reset! s5-1)
+            (dotimes (s4-1 (-> *collide-cache* num-tris))
+              (let* ((v1-16 (-> *collide-cache* tris s4-1))
+                     (s2-1 (vector-! (new 'stack-no-clear 'vector) (-> v1-16 vertex 1) (the-as vector (-> v1-16 vertex))))
+                     (s1-1 (vector-! (new 'stack-no-clear 'vector) (-> v1-16 vertex 2) (the-as vector (-> v1-16 vertex))))
+                     (s3-0 (new 'stack-no-clear 'vector))
+                     )
+                (vector-normalize! s2-1 1.0)
+                (vector-normalize! s1-1 1.0)
+                (vector-cross! s3-0 s2-1 s1-1)
+                (if (< (cos 10922.667) (vector-dot s3-0 *y-vector*))
+                    (vector+! s5-1 s5-1 s3-0)
+                    )
+                )
+              )
+            (vector-normalize-copy! (-> obj gspot-normal) s5-1 1.0)
+            )
+          (set! (-> obj gspot-timer) (-> pp clock frame-counter))
+          )
+        #t
+        )
+      )
+    )
+  )
+
+;; definition for method 182 of type flying-spider
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod flying-spider-method-182 flying-spider ((obj flying-spider) (arg0 vector))
+  (with-pp
+    (cond
+      ((= (-> obj root-override2 gspot-pos y) -40959590.0)
+       (set! (-> arg0 y) 0.0)
+       (vector-normalize! arg0 1.0)
+       (quaternion-set! (-> obj root-override2 quat) 0.0 (-> arg0 x) 0.0 (+ 1.0 (-> arg0 z)))
+       (quaternion-normalize! (-> obj root-override2 quat))
+       )
+      (else
+        (let ((s4-0 (new 'stack-no-clear 'vector)))
+          (set! (-> s4-0 quad) (-> *up-vector* quad))
+          (let ((s3-0 (new 'stack-no-clear 'quaternion)))
+            (quaternion-from-two-vectors-max-angle! s3-0 s4-0 (-> obj gspot-normal) 4551.1113)
+            (vector-orient-by-quat! s4-0 s4-0 s3-0)
+            )
+          (let ((s3-1 (-> obj my-up-vector)))
+            (new 'stack-no-clear 'vector)
+            (vector-deg-seek s3-1 s3-1 s4-0 (* 910.2222 (-> pp clock seconds-per-frame)))
+            (vector-normalize! s3-1 1.0)
+            (set! (-> arg0 y) 0.0)
+            (vector-normalize! arg0 1.0)
+            (forward-up->quaternion (-> obj root-override2 quat) arg0 s3-1)
+            )
+          )
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+;; definition for method 142 of type flying-spider
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod nav-enemy-method-142 flying-spider ((obj flying-spider) (arg0 nav-control))
+  (let ((t9-0 (method-of-object obj flying-spider-method-182))
+        (a2-0 (-> arg0 state))
+        (a1-1 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> a1-1 quad) (-> a2-0 heading quad))
+    (t9-0 obj a1-1)
+    )
+  0
+  (none)
+  )
+
+;; definition for method 109 of type flying-spider
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-109 flying-spider ((obj flying-spider) (arg0 int))
+  0
+  (none)
+  )
+
+;; definition for method 59 of type flying-spider
+;; WARN: Return type mismatch int vs penetrate.
+(defmethod enemy-method-59 flying-spider ((obj flying-spider))
+  (the-as penetrate 0)
+  )
+
+;; definition for method 51 of type flying-spider
+(defmethod enemy-method-51 flying-spider ((obj flying-spider))
+  (quaternion-y-angle (-> obj root-override2 quat))
+  )
+
+;; definition for method 60 of type flying-spider
+(defmethod coin-flip? flying-spider ((obj flying-spider))
+  "@returns The result of a 50/50 RNG roll"
+  #f
+  )
+
+;; definition for method 114 of type flying-spider
+;; WARN: Return type mismatch collide-shape-moving vs none.
+(defmethod enemy-method-114 flying-spider ((obj flying-spider))
+  "@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))
+    (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 enemy pusher))
+      (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 can-ride deadly no-standon))
+      (set! (-> s4-0 transform-index) 3)
+      (set-vector! (-> s4-0 local-sphere) 0.0 3072.0 0.0 16384.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (pusher-init s5-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 pusher))
+      (set! (-> v1-15 prim-core collide-with)
+            (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list)
+            )
+      (set! (-> v1-15 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set-vector! (-> v1-15 local-sphere) 0.0 7372.8 0.0 7372.8)
+      )
+    (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 pusher))
+      (set! (-> v1-17 prim-core action) (collide-action solid can-ride no-standon))
+      (set! (-> v1-17 transform-index) 24)
+      (set-vector! (-> v1-17 local-sphere) 0.0 4096.0 -819.2 7372.8)
+      )
+    (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 pusher))
+      (set! (-> v1-19 prim-core action) (collide-action solid can-ride no-standon))
+      (set! (-> v1-19 transform-index) 27)
+      (set-vector! (-> v1-19 local-sphere) 0.0 -819.2 819.2 4096.0)
+      )
+    (let ((v1-21 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-21 prim-core collide-as) (collide-spec enemy pusher))
+      (set! (-> v1-21 prim-core action) (collide-action solid can-ride no-standon))
+      (set! (-> v1-21 transform-index) 3)
+      (set-vector! (-> v1-21 local-sphere) 6144.0 -2457.6 -3276.8 5734.4)
+      )
+    (let ((v1-23 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-23 prim-core collide-as) (collide-spec enemy pusher))
+      (set! (-> v1-23 prim-core action) (collide-action solid can-ride no-standon))
+      (set! (-> v1-23 transform-index) 3)
+      (set-vector! (-> v1-23 local-sphere) -6144.0 -2457.6 -3276.8 5734.4)
+      )
+    (set! (-> s5-0 nav-radius) 12288.0)
+    (let ((v1-25 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-25 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-25 prim-core collide-with))
+      )
+    (set! (-> obj root-override2) s5-0)
+    )
+  (none)
+  )
+
+;; definition for method 115 of type flying-spider
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-115 flying-spider ((obj flying-spider))
+  "@abstract"
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-flying-spider" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (enemy-method-113 obj *flying-spider-nav-enemy-info*)
+  (let ((v1-5 (-> obj neck)))
+    (set! (-> v1-5 up) (the-as uint 1))
+    (set! (-> v1-5 nose) (the-as uint 2))
+    (set! (-> v1-5 ear) (the-as uint 0))
+    (set-vector! (-> v1-5 twist-max) 11832.889 11832.889 0.0 1.0)
+    (set! (-> v1-5 ignore-angle) 30947.555)
+    )
+  (set! (-> obj root-override2 dynam gravity y) 327680.0)
+  (set! (-> obj root-override2 dynam gravity-length) 327680.0)
+  (set! (-> obj root-override2 dynam gravity-max) 327680.0)
+  (set! (-> obj path) (new 'process 'curve-control obj 'path -1000000000.0))
+  (set! (-> obj path-u) 0.0)
+  (logior! (-> obj path flags) (path-control-flag display draw-line draw-point draw-text))
+  (add-connection *part-engine* obj 27 obj 318 (new 'static 'vector :x 1392.64 :y 204.8 :z 2621.44 :w 163840.0))
+  (add-connection
+    *part-engine*
+    obj
+    27
+    obj
+    318
+    (new 'static 'vector :x -1392.64 :y 204.8 :z 2621.44 :w 163840.0)
+    )
+  (set! (-> obj my-up-vector quad) (-> *y-vector* quad))
+  (set! (-> obj gspot-normal quad) (-> *y-vector* quad))
+  (set! (-> obj gspot-timer) 0)
+  0
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/nest/mammoth_REF.gc b/test/decompiler/reference/jak2/levels/nest/mammoth_REF.gc
new file mode 100644
index 0000000000..c4b988f525
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/nest/mammoth_REF.gc
@@ -0,0 +1,1884 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type mammoth
+(deftype mammoth (nav-enemy)
+  ((joint-ik               joint-mod-ik 4         :offset-assert 604)
+   (ik-handle-pos          vector       4 :inline :offset-assert 624)
+   (ik-handle-y            float        4         :offset-assert 688)
+   (heel-lerp              float        4         :offset-assert 704)
+   (foot-flags             uint16                 :offset-assert 720)
+   (old-foot-flags         uint16                 :offset-assert 722)
+   (y-level                float                  :offset-assert 724)
+   (foot-pos               vector       4 :inline :offset-assert 736)
+   (my-up-vector           vector       :inline   :offset-assert 800)
+   (my-up-quat             quaternion   :inline   :offset-assert 816)
+   (move-pos               vector       2 :inline :offset-assert 832)
+   (travel-dest            vector       :inline   :offset-assert 864)
+   (tilt-quat              quaternion   :inline   :offset-assert 880)
+   (path-index             int32                  :offset-assert 896)
+   (path-index-dir         int32                  :offset-assert 900)
+   (path-pos               float                  :offset-assert 904)
+   (turn-angle             float                  :offset-assert 908)
+   (gspot-timer            time-frame             :offset-assert 912)
+   (gspot-normal           vector       :inline   :offset-assert 928)
+   (attack-timer           time-frame             :offset-assert 944)
+   (lightning-timer        time-frame             :offset-assert 952)
+   (lightning-attack-timer time-frame             :offset-assert 960)
+   (spawn-timer            time-frame             :offset-assert 968)
+   (turn-anim-start        int32                  :offset-assert 976)
+   (turn-anim              int32                  :offset-assert 980)
+   (turn-anim-end          int32                  :offset-assert 984)
+   (turn-move-start        float                  :offset-assert 988)
+   (turn-move-end          float                  :offset-assert 992)
+   (feet-ik-init-timer     time-frame             :offset-assert 1000)
+   )
+  :heap-base #x370
+  :method-count-assert 186
+  :size-assert         #x3f0
+  :flag-assert         #xba037003f0
+  (:methods
+    (waiting () _type_ :state 178)
+    (wait-to-walk () _type_ :state 179)
+    (walking () _type_ :state 180)
+    (walking-attack () _type_ :state 181)
+    (turning () _type_ :state 182)
+    (mammoth-method-183 (_type_) none 183)
+    (mammoth-method-184 (_type_) none 184)
+    (mammoth-method-185 (_type_ vector int) none 185)
+    )
+  )
+
+;; definition for method 3 of type mammoth
+(defmethod inspect mammoth ((obj mammoth))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type nav-enemy inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tjoint-ik[4] @ #x~X~%" (-> obj joint-ik))
+  (format #t "~2Tik-handle-pos[4] @ #x~X~%" (-> obj ik-handle-pos))
+  (format #t "~2Tik-handle-y[4] @ #x~X~%" (-> obj ik-handle-y))
+  (format #t "~2Theel-lerp[4] @ #x~X~%" (-> obj heel-lerp))
+  (format #t "~2Tfoot-flags: ~D~%" (-> obj foot-flags))
+  (format #t "~2Told-foot-flags: ~D~%" (-> obj old-foot-flags))
+  (format #t "~2Ty-level: ~f~%" (-> obj y-level))
+  (format #t "~2Tfoot-pos[4] @ #x~X~%" (-> obj foot-pos))
+  (format #t "~2Tmy-up-vector: #<vector @ #x~X>~%" (-> obj my-up-vector))
+  (format #t "~2Tmy-up-quat: #<quaternion @ #x~X>~%" (-> obj my-up-quat))
+  (format #t "~2Tmove-pos[2] @ #x~X~%" (-> obj move-pos))
+  (format #t "~2Ttravel-dest: #<vector @ #x~X>~%" (-> obj travel-dest))
+  (format #t "~2Ttilt-quat: #<quaternion @ #x~X>~%" (-> obj tilt-quat))
+  (format #t "~2Tpath-index: ~D~%" (-> obj path-index))
+  (format #t "~2Tpath-index-dir: ~D~%" (-> obj path-index-dir))
+  (format #t "~2Tpath-pos: ~f~%" (-> obj path-pos))
+  (format #t "~2Tturn-angle: ~f~%" (-> obj turn-angle))
+  (format #t "~2Tgspot-timer: ~D~%" (-> obj gspot-timer))
+  (format #t "~2Tgspot-normal: #<vector @ #x~X>~%" (-> obj gspot-normal))
+  (format #t "~2Tattack-timer: ~D~%" (-> obj attack-timer))
+  (format #t "~2Tlightning-timer: ~D~%" (-> obj lightning-timer))
+  (format #t "~2Tlightning-attack-timer: ~D~%" (-> obj lightning-attack-timer))
+  (format #t "~2Tspawn-timer: ~D~%" (-> obj spawn-timer))
+  (format #t "~2Tturn-anim-start: ~D~%" (-> obj turn-anim-start))
+  (format #t "~2Tturn-anim: ~D~%" (-> obj turn-anim))
+  (format #t "~2Tturn-anim-end: ~D~%" (-> obj turn-anim-end))
+  (format #t "~2Tturn-move-start: ~f~%" (-> obj turn-move-start))
+  (format #t "~2Tturn-move-end: ~f~%" (-> obj turn-move-end))
+  (format #t "~2Tfeet-ik-init-timer: ~D~%" (-> obj feet-ik-init-timer))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-mammoth mammoth mammoth-lod0-jg mammoth-walk0-ja
+              ((mammoth-lod0-mg (meters 20)) (mammoth-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0 4.5 0 17)
+              :shadow mammoth-shadow-mg
+              )
+
+;; definition for symbol *mammoth-nav-enemy-info*, type nav-enemy-info
+(define *mammoth-nav-enemy-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #f
+    :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 idle-control-frame 4
+      (new 'static 'idle-control-frame :command (ic-cmd push) :param0 #x1e)
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x6 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 6
+    :notice-anim 6
+    :hostile-anim 6
+    :hit-anim 6
+    :knocked-anim 6
+    :knocked-land-anim 6
+    :die-anim -1
+    :die-falling-anim -1
+    :victory-anim 6
+    :jump-wind-up-anim -1
+    :jump-in-air-anim -1
+    :jump-land-anim -1
+    :neck-joint 6
+    :look-at-joint 7
+    :bullseye-joint 7
+    :notice-distance (meters 30)
+    :notice-distance-delta (meters 10)
+    :default-hit-points 80
+    :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
+    :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 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)
+    :callback-info #f
+    :use-momentum #f
+    :use-frustration #f
+    :use-stop-chase #f
+    :use-circling #f
+    :use-pacing #f
+    :walk-anim 6
+    :turn-anim 6
+    :run-anim 7
+    :taunt-anim 6
+    :run-travel-speed (meters 6)
+    :run-acceleration (meters 1)
+    :run-turning-acceleration (meters 20)
+    :walk-travel-speed (meters 4.5)
+    :walk-acceleration (meters 10)
+    :walk-turning-acceleration (meters 1)
+    :maximum-rotation-rate (degrees 31.249998)
+    :notice-nav-radius (meters 1)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :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! (-> *mammoth-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+;; definition for symbol *mammoth-lightning-joint-tbl*, type (array int32)
+(define *mammoth-lightning-joint-tbl* (new 'static 'boxed-array :type int32 50 51 52 53 54 55))
+
+;; definition of type mammoth-ik-setup
+(deftype mammoth-ik-setup (structure)
+  ((elbow-index int32   :offset-assert   0)
+   (hand-dist   float   :offset-assert   4)
+   (ground-dist float   :offset-assert   8)
+   (foot-flag   uint16  :offset-assert  12)
+   )
+  :method-count-assert 9
+  :size-assert         #xe
+  :flag-assert         #x90000000e
+  )
+
+;; definition for method 3 of type mammoth-ik-setup
+(defmethod inspect mammoth-ik-setup ((obj mammoth-ik-setup))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'mammoth-ik-setup)
+  (format #t "~1Telbow-index: ~D~%" (-> obj elbow-index))
+  (format #t "~1Thand-dist: ~f~%" (-> obj hand-dist))
+  (format #t "~1Tground-dist: ~f~%" (-> obj ground-dist))
+  (format #t "~1Tfoot-flag: ~D~%" (-> obj foot-flag))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for symbol *mammoth-ik-setup*, type (inline-array mammoth-ik-setup)
+(define *mammoth-ik-setup*
+  (new 'static 'inline-array mammoth-ik-setup 4
+    (new 'static 'mammoth-ik-setup :elbow-index 9 :hand-dist 5640.192 :ground-dist 6789.12 :foot-flag #x1)
+    (new 'static 'mammoth-ik-setup :elbow-index 12 :hand-dist -5640.192 :ground-dist 6789.12 :foot-flag #x2)
+    (new 'static 'mammoth-ik-setup :elbow-index 24 :hand-dist 6574.08 :ground-dist 3913.728 :foot-flag #x8)
+    (new 'static 'mammoth-ik-setup :elbow-index 27 :hand-dist -6574.08 :ground-dist 3913.728 :foot-flag #x4)
+    )
+  )
+
+;; definition for function mammoth-walk-post
+(defbehavior mammoth-walk-post mammoth ()
+  (compute-alignment! (-> self align))
+  (align-vel-and-quat-only!
+    (-> self align)
+    (align-opts adjust-xz-vel)
+    (vector-normalize! (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat)) 65536.0)
+    #x3f800000
+    1.0
+    1.0
+    )
+  (+! (-> self root-override2 transv y)
+      (* (-> self enemy-info-override movement-gravity) (-> self clock seconds-per-frame))
+      )
+  (let ((a2-1 (new 'stack-no-clear 'move-above-ground-params)))
+    (let ((v1-9 (-> self enemy-info-override)))
+      (set! (-> a2-1 gnd-collide-with) (the-as collide-spec (-> self gnd-collide)))
+      (set! (-> a2-1 popup) 8192.0)
+      (set! (-> a2-1 dont-move-if-overlaps?) #f)
+      (set! (-> a2-1 hover-if-no-ground?) #f)
+      (set! (-> a2-1 overlaps-params options) (overlaps-others-options oo0 oo2))
+      (set! (-> a2-1 overlaps-params collide-with-filter) (-> v1-9 overlaps-others-collide-with-filter))
+      )
+    (set! (-> a2-1 overlaps-params tlist) *touching-list*)
+    (-> a2-1 overlaps-params)
+    (enemy-method-128 self (-> self root-override2 transv) a2-1)
+    )
+  (do-push-aways (-> self root-override2))
+  (let ((s5-1
+          (vector-normalize!
+            (vector-! (new 'stack-no-clear 'vector) (-> self travel-dest) (-> self root-override2 trans))
+            1.0
+            )
+          )
+        (gp-1 (new 'stack-no-clear 'quaternion))
+        )
+    (set! (-> s5-1 y) 0.0)
+    (vector-normalize! s5-1 1.0)
+    (quaternion-set! gp-1 0.0 (-> s5-1 x) 0.0 (+ 1.0 (-> s5-1 z)))
+    (quaternion-normalize! gp-1)
+    (quaternion-slerp!
+      (-> self root-override2 quat)
+      (-> self root-override2 quat)
+      gp-1
+      (* 0.3 (-> self clock seconds-per-frame))
+      )
+    )
+  (nav-enemy-simple-post)
+  (none)
+  )
+
+;; definition for function mammoth-walk-check-end
+;; WARN: Return type mismatch object vs none.
+(defbehavior mammoth-walk-check-end mammoth ()
+  (let ((a1-1 (vector-! (new 'stack-no-clear 'vector) (-> self move-pos 1) (the-as vector (-> self move-pos))))
+        (gp-1
+          (vector-! (new 'stack-no-clear 'vector) (-> self root-override2 trans) (the-as vector (-> self move-pos)))
+          )
+        )
+    (if (< (vector-length a1-1) (vector-dot gp-1 (vector-normalize-copy! (new 'stack-no-clear 'vector) a1-1 1.0)))
+        (go-virtual turning)
+        )
+    )
+  (none)
+  )
+
+;; definition for function next-path-index
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defbehavior next-path-index mammoth ()
+  (cond
+    ((= (-> self path-index-dir) 1)
+     (if (= (-> self path-index) (the int (get-num-segments (-> self path))))
+         (set! (-> self path-index-dir) -1)
+         )
+     (+! (-> self path-index) (-> self path-index-dir))
+     )
+    (else
+      (if (zero? (-> self path-index))
+          (set! (-> self path-index-dir) 1)
+          )
+      (+! (-> self path-index) (-> self path-index-dir))
+      )
+    )
+  (let ((gp-0
+          (get-point-in-path! (-> self path) (new 'stack-no-clear 'vector) (the float (-> self path-index)) 'interp)
+          )
+        )
+    (cloest-point-on-mesh (-> self nav) gp-0 gp-0 (the-as nav-poly #f))
+    (set! (-> self move-pos 0 quad) (-> self move-pos 1 quad))
+    (set! (-> self move-pos 1 quad) (-> gp-0 quad))
+    )
+  0
+  (none)
+  )
+
+;; definition for function set-nav-destination
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defbehavior set-nav-destination mammoth ()
+  (let ((s5-1 (vector-! (new 'stack-no-clear 'vector) (-> self move-pos 1) (the-as vector (-> self move-pos))))
+        (s4-0 (new 'stack-no-clear 'vector))
+        (gp-0 (new 'stack-no-clear 'vector))
+        )
+    (vector-normalize! s5-1 65536.0)
+    (vector-line-distance-point!
+      (-> self root-override2 trans)
+      (the-as vector (-> self move-pos))
+      (-> self move-pos 1)
+      s4-0
+      )
+    (vector+! gp-0 s4-0 s5-1)
+    (cloest-point-on-mesh (-> self nav) gp-0 gp-0 (the-as nav-poly #f))
+    (set! (-> self travel-dest quad) (-> gp-0 quad))
+    )
+  (let ((a0-5 (-> self nav state))
+        (v1-8 (-> self travel-dest))
+        )
+    (logclear! (-> a0-5 flags) (nav-state-flag directional-mode))
+    (logior! (-> a0-5 flags) (nav-state-flag target-poly-dirty))
+    (set! (-> a0-5 target-post quad) (-> v1-8 quad))
+    )
+  0
+  (none)
+  )
+
+;; definition for function mammoth-walk-handler
+(defbehavior mammoth-walk-handler mammoth ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (local-vars (v0-0 object))
+  (case arg2
+    (('event-rl-down)
+     (set! v0-0 (logior (-> self foot-flags) 8))
+     (set! (-> self foot-flags) (the-as uint v0-0))
+     v0-0
+     )
+    (('event-rr-up)
+     (set! v0-0 (logand -5 (-> self foot-flags)))
+     (set! (-> self foot-flags) (the-as uint v0-0))
+     v0-0
+     )
+    (('event-fl-down)
+     (set! v0-0 (logior (-> self foot-flags) 1))
+     (set! (-> self foot-flags) (the-as uint v0-0))
+     v0-0
+     )
+    (('event-fr-up)
+     (set! v0-0 (logand -3 (-> self foot-flags)))
+     (set! (-> self foot-flags) (the-as uint v0-0))
+     v0-0
+     )
+    (('event-rr-down)
+     (set! v0-0 (logior (-> self foot-flags) 4))
+     (set! (-> self foot-flags) (the-as uint v0-0))
+     v0-0
+     )
+    (('event-rl-up)
+     (set! v0-0 (logand -9 (-> self foot-flags)))
+     (set! (-> self foot-flags) (the-as uint v0-0))
+     v0-0
+     )
+    (('event-fr-down)
+     (set! v0-0 (logior (-> self foot-flags) 2))
+     (set! (-> self foot-flags) (the-as uint v0-0))
+     v0-0
+     )
+    (('event-fl-up)
+     (set! v0-0 (logand -2 (-> self foot-flags)))
+     (set! (-> self foot-flags) (the-as uint v0-0))
+     v0-0
+     )
+    (else
+      (enemy-event-handler arg0 arg1 arg2 arg3)
+      )
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate waiting (mammoth)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('cue-chase)
+       (go-virtual wait-to-walk)
+       )
+      )
+    )
+  :enter (behavior ()
+    (let ((v1-0 self))
+      (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logclear (-> v1-0 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-0 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (let ((v1-3 self))
+      (set! (-> v1-3 enemy-flags) (the-as enemy-flag (logclear (-> v1-3 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (logior! (-> self foot-flags) 15)
+    (none)
+    )
+  :code (behavior ()
+    (move-to-ground (-> self root-override2) 40960.0 122880.0 #t (collide-spec backgnd))
+    (dotimes (v1-2 4)
+      (set! (-> self ik-handle-pos v1-2 quad) (-> self root-override2 trans quad))
+      (set! (-> self ik-handle-y v1-2) (-> self root-override2 trans y))
+      )
+    (ja-channel-push! 1 (seconds 0.1))
+    (until #f
+      (ja-no-eval :group! mammoth-idle0-ja
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim mammoth-idle0-ja) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior mammoth) nav-enemy-simple-post)
+  )
+
+;; failed to figure out what this is:
+(defstate wait-to-walk (mammoth)
+  :virtual #t
+  :event mammoth-walk-handler
+  :enter (behavior ()
+    (nav-enemy-method-165 self)
+    (let ((v1-2 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-2 enemy-flags)))
+          (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-2 enemy-flags))))
+          )
+      (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-2 enemy-flags))))
+      (set! (-> v1-2 nav callback-info) (-> v1-2 enemy-info-override callback-info))
+      )
+    0
+    (let ((v1-5 self))
+      (set! (-> v1-5 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-5 enemy-flags))))
+      )
+    0
+    (none)
+    )
+  :code (behavior ()
+    (next-path-index)
+    (set-nav-destination)
+    (ja-channel-push! 1 (seconds 0.1))
+    (ja-no-eval :group! mammoth-idle0-to-walk-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mammoth-idle0-to-walk-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (go-virtual walking)
+    (none)
+    )
+  :post mammoth-walk-post
+  )
+
+;; failed to figure out what this is:
+(defstate walking (mammoth)
+  :virtual #t
+  :event mammoth-walk-handler
+  :enter (behavior ()
+    (nav-enemy-method-165 self)
+    (let ((v1-2 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-2 enemy-flags)))
+          (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-2 enemy-flags))))
+          )
+      (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-2 enemy-flags))))
+      (set! (-> v1-2 nav callback-info) (-> v1-2 enemy-info-override callback-info))
+      )
+    0
+    (let ((v1-5 self))
+      (set! (-> v1-5 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-5 enemy-flags))))
+      )
+    0
+    (logior! (-> self foot-flags) 6)
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.1))
+    (let ((v1-2 (ja-group)))
+      (when (not (or (and v1-2 (= v1-2 mammoth-walk0-ja))
+                     (let ((v1-8 (ja-group)))
+                       (and v1-8 (= v1-8 mammoth-walk1-ja))
+                       )
+                     (let ((v1-13 (ja-group)))
+                       (and v1-13 (= v1-13 mammoth-idle0-to-walk-ja))
+                       )
+                     )
+                 )
+        )
+      )
+    (until #f
+      (mammoth-walk-check-end)
+      (set-nav-destination)
+      (let ((v1-20 (if (rng-hit? self 0.5)
+                       6
+                       7
+                       )
+                   )
+            )
+        (ja-no-eval :group! (-> self draw art-group data v1-20)
+                    :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data v1-20)) frames num-frames) -1)))
+                    :frame-num 0.0
+                    )
+        )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      (mammoth-walk-check-end)
+      (when (>= (- (-> self clock frame-counter) (-> self attack-timer)) (seconds 5))
+        (set! (-> self attack-timer) (-> self clock frame-counter))
+        (go-virtual walking-attack)
+        )
+      )
+    #f
+    (none)
+    )
+  :post mammoth-walk-post
+  )
+
+;; failed to figure out what this is:
+(defstate walking-attack (mammoth)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('event-attack)
+       (let ((v0-0 (the-as object (-> self clock frame-counter))))
+         (set! (-> self lightning-timer) (the-as time-frame v0-0))
+         v0-0
+         )
+       )
+      (else
+        (mammoth-walk-handler proc arg1 event-type event)
+        )
+      )
+    )
+  :enter (behavior ()
+    (nav-enemy-method-165 self)
+    (let ((v1-2 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-2 enemy-flags)))
+          (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-2 enemy-flags))))
+          )
+      (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-2 enemy-flags))))
+      (set! (-> v1-2 nav callback-info) (-> v1-2 enemy-info-override callback-info))
+      )
+    0
+    (let ((v1-5 self))
+      (set! (-> v1-5 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-5 enemy-flags))))
+      )
+    0
+    (logior! (-> self foot-flags) 6)
+    (none)
+    )
+  :trans (behavior ()
+    (when (and (< (- (-> self clock frame-counter) (-> self lightning-timer)) (seconds 3))
+               (< (-> self spawn-timer) (-> self clock frame-counter))
+               )
+      (let ((s5-0 *mammoth-lightning-joint-tbl*))
+        (mammoth-method-185 self (-> self root-override2 trans) (-> s5-0 (get-rand-int self (-> s5-0 length))))
+        )
+      (set! (-> self spawn-timer)
+            (+ (-> self clock frame-counter) (the int (* 300.0 (get-rand-float-range self 0.0 0.1))))
+            )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (set-nav-destination)
+    (ja-channel-push! 1 (seconds 0.1))
+    (ja-no-eval :group! mammoth-walk-fire0-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mammoth-walk-fire0-ja) frames num-frames) -1)) 0.8)
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! max 0.8))
+      )
+    (until #f
+      (mammoth-walk-check-end)
+      (set-nav-destination)
+      (ja-no-eval :group! mammoth-walk0-ja
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim mammoth-walk0-ja) frames num-frames) -1)) 0.8)
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max 0.8))
+        )
+      (mammoth-walk-check-end)
+      (when (>= (- (-> self clock frame-counter) (-> self attack-timer)) (seconds 3))
+        (set! (-> self attack-timer) (-> self clock frame-counter))
+        (go-virtual walking)
+        )
+      )
+    #f
+    (none)
+    )
+  :post mammoth-walk-post
+  )
+
+;; failed to figure out what this is:
+(defstate turning (mammoth)
+  :virtual #t
+  :event mammoth-walk-handler
+  :enter (behavior ()
+    (next-path-index)
+    (let ((gp-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat)))
+          (s5-0 (new 'stack-no-clear 'vector))
+          )
+      (set! (-> gp-0 y) 0.0)
+      (vector-xz-normalize! gp-0 1.0)
+      (vector-! s5-0 (-> self move-pos 1) (-> self root-override2 trans))
+      (set! (-> s5-0 y) 0.0)
+      (vector-xz-normalize! s5-0 1.0)
+      (set! (-> self turn-angle) (deg- (vector-y-angle s5-0) (vector-y-angle gp-0)))
+      )
+    (cond
+      ((< 23665.777 (-> self turn-angle))
+       (set! (-> self turn-anim-start) 14)
+       (set! (-> self turn-anim) 15)
+       (set! (-> self turn-anim-end) -1)
+       (set! (-> self turn-move-start) 20480.0)
+       (set! (-> self turn-move-end) 0.0)
+       (set! (-> self turn-angle) 27306.666)
+       )
+      ((< 5461.3335 (-> self turn-angle))
+       (set! (-> self turn-anim-start) 12)
+       (set! (-> self turn-anim) 13)
+       (set! (-> self turn-anim-end) -1)
+       (set! (-> self turn-move-start) 10240.0)
+       (set! (-> self turn-move-end) 0.0)
+       (set! (-> self turn-angle) 9102.223)
+       )
+      ((< -5461.3335 (-> self turn-angle))
+       (set! (-> self turn-anim-start) -1)
+       (set! (-> self turn-anim) -1)
+       (set! (-> self turn-anim-end) -1)
+       (set! (-> self turn-move-start) 0.0)
+       (set! (-> self turn-move-end) 0.0)
+       (set! (-> self turn-angle) 0.0)
+       )
+      ((< -23665.777 (-> self turn-angle))
+       (set! (-> self turn-anim-start) -1)
+       (set! (-> self turn-anim) 16)
+       (set! (-> self turn-anim-end) -1)
+       (set! (-> self turn-move-start) 0.0)
+       (set! (-> self turn-move-end) 0.0)
+       (set! (-> self turn-angle) -9102.223)
+       )
+      (else
+        (set! (-> self turn-anim-start) -1)
+        (set! (-> self turn-anim) 17)
+        (set! (-> self turn-anim-end) 18)
+        (set! (-> self turn-move-start) 0.0)
+        (set! (-> self turn-move-end) -10240.0)
+        (set! (-> self turn-angle) -27306.666)
+        )
+      )
+    (let ((v1-33 self))
+      (set! (-> v1-33 enemy-flags) (the-as enemy-flag (logclear (-> v1-33 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.1))
+    (when (!= (-> self turn-anim-start) -1)
+      (let ((gp-0 (-> self draw art-group data (-> self turn-anim-start))))
+        (let ((v1-7 (vector-z-quaternion! (-> self root-override2 transv) (-> self root-override2 quat)))
+              (a0-6 (-> self root-override2 trans))
+              )
+          (set! (-> (new 'stack-no-clear 'vector) quad) (-> a0-6 quad))
+          (vector+float*! (new 'stack-no-clear 'vector) a0-6 v1-7 (-> self turn-move-start))
+          )
+        (ja-no-eval :group! gp-0
+                    :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) 0.6667)
+                    :frame-num 0.0
+                    )
+        )
+      (until (ja-done? 0)
+        (compute-alignment! (-> self align))
+        (align! (-> self align) (align-opts adjust-xz-vel adjust-quat) 1.0 1.0 1.0)
+        (suspend)
+        (ja :num! (seek! max 0.6667))
+        )
+      )
+    (when (!= (-> self turn-anim) -1)
+      (ja-no-eval :group! (-> self draw art-group data (-> self turn-anim))
+                  :num! (seek!
+                    (the float
+                         (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self turn-anim))) frames num-frames) -1)
+                         )
+                    0.6667
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (compute-alignment! (-> self align))
+        (align! (-> self align) (align-opts adjust-xz-vel adjust-quat) 1.0 1.0 1.0)
+        (suspend)
+        (ja :num! (seek! max 0.6667))
+        )
+      )
+    (when (!= (-> self turn-anim-end) -1)
+      (let ((gp-1 (-> self draw art-group data (-> self turn-anim-end))))
+        (let ((v1-68 (vector-z-quaternion! (-> self root-override2 transv) (-> self root-override2 quat)))
+              (a0-23 (-> self root-override2 trans))
+              )
+          (set! (-> (new 'stack-no-clear 'vector) quad) (-> a0-23 quad))
+          (vector+float*! (new 'stack-no-clear 'vector) a0-23 v1-68 (-> self turn-move-end))
+          )
+        (ja-no-eval :group! gp-1
+                    :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-1) frames num-frames) -1)) 0.6667)
+                    :frame-num 0.0
+                    )
+        )
+      (until (ja-done? 0)
+        (compute-alignment! (-> self align))
+        (align! (-> self align) (align-opts adjust-xz-vel adjust-quat) 1.0 1.0 1.0)
+        (suspend)
+        (ja :num! (seek! max 0.6667))
+        )
+      )
+    (go-virtual walking)
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-simple-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate die (mammoth)
+  :virtual #t
+  :code (behavior ()
+    (set-nav-destination)
+    (ja-no-eval :group! mammoth-death-right-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mammoth-death-right-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (ja-no-eval :group! mammoth-death-right-fall-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mammoth-death-right-fall-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (ja-no-eval :group! mammoth-death-right-fall-end-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mammoth-death-right-fall-end-ja) 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)
+    )
+  :post mammoth-walk-post
+  )
+
+;; definition for method 74 of type mammoth
+(defmethod enemy-method-74 mammoth ((obj mammoth) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (case arg2
+    (('hit)
+     (logclear! (-> obj mask) (process-mask actor-pause))
+     (logclear! (-> obj focus-status) (focus-status dangerous))
+     (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice))
+     (logior! (-> obj enemy-flags) (enemy-flag chase-startup))
+     (logior! (-> obj focus-status) (focus-status hit))
+     (if (zero? (-> obj hit-points))
+         (logior! (-> obj focus-status) (focus-status dead))
+         )
+     (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup))
+     (enemy-method-62 obj)
+     (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
+     (process-contact-action arg0)
+     (send-event arg0 'get-attack-count 1)
+     )
+    (else
+      ((method-of-type nav-enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+      )
+    )
+  )
+
+;; definition for method 185 of type mammoth
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod mammoth-method-185 mammoth ((obj mammoth) (arg0 vector) (arg1 int))
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         (vf7 :class vf)
+         )
+    (init-vf0-vector)
+    (let ((s1-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data arg1)))
+          (s2-0 (new 'stack-no-clear 'vector))
+          )
+      (let ((s4-1
+              (vector-normalize! (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)) 16384.0)
+              )
+            )
+        (vector-! s2-0 s1-0 arg0)
+        (set! (-> s2-0 y) 0.0)
+        (vector-xz-normalize! s2-0 49152.0)
+        (set! (-> s2-0 y) (+ -81920.0 (-> s2-0 y)))
+        (vector+! s2-0 s2-0 s4-1)
+        )
+      (let ((s3-1 (new 'stack-no-clear 'collide-query))
+            (s4-2 (new 'stack-no-clear 'matrix))
+            )
+        (matrix->trans (-> obj node-list data arg1 bone transform) (-> s3-1 start-pos))
+        (set! (-> s3-1 move-dist quad) (-> s2-0 quad))
+        (let ((v1-11 s3-1))
+          (set! (-> v1-11 radius) 4.096)
+          (set! (-> v1-11 collide-with) (collide-spec backgnd obstacle))
+          (set! (-> v1-11 ignore-process0) #f)
+          (set! (-> v1-11 ignore-process1) #f)
+          (set! (-> v1-11 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+          (set! (-> v1-11 action-mask) (collide-action solid))
+          )
+        (fill-using-line-sphere *collide-cache* s3-1)
+        (let ((f0-4 (probe-using-line-sphere *collide-cache* s3-1)))
+          (when (>= f0-4 0.0)
+            (let ((a0-16 s4-2))
+              (let ((v1-17 (-> s3-1 start-pos)))
+                (let ((a1-9 (-> s3-1 move-dist)))
+                  (let ((a2-1 f0-4))
+                    (.mov vf7 a2-1)
+                    )
+                  (.lvf vf5 (&-> a1-9 quad))
+                  )
+                (.lvf vf4 (&-> v1-17 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-16 quad 0) vf6)
+              )
+            (process-spawn
+              lightning-tracker
+              :init lightning-tracker-init
+              (-> *lightning-spec-id-table* 1)
+              600
+              #f
+              obj
+              arg1
+              s4-2
+              :to *entity-pool*
+              )
+            )
+          )
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+;; definition for method 67 of type mammoth
+;; WARN: Return type mismatch object vs none.
+(defmethod go-stare mammoth ((obj mammoth))
+  (go (method-of-object obj walking))
+  (none)
+  )
+
+;; definition for method 70 of type mammoth
+;; WARN: Return type mismatch object vs none.
+(defmethod go-hostile mammoth ((obj mammoth))
+  (go (method-of-object obj walking))
+  (none)
+  )
+
+;; definition for method 116 of type mammoth
+;; WARN: Return type mismatch object vs none.
+(defmethod go-idle mammoth ((obj mammoth))
+  (go (method-of-object obj waiting))
+  (none)
+  )
+
+;; definition for method 125 of type mammoth
+;; WARN: Return type mismatch symbol vs pat-surface.
+(defmethod enemy-method-125 mammoth ((obj mammoth) (arg0 collide-query) (arg1 collide-spec) (arg2 float) (arg3 float) (arg4 float))
+  (with-pp
+    (the-as
+      pat-surface
+      (when (find-ground (-> obj root-override2) arg0 arg1 arg2 arg3 arg4)
+        (set! (-> obj root-override2 ground-pat) (-> arg0 best-other-tri pat))
+        (let ((s3-0 (new 'stack-no-clear 'collide-query)))
+          (let ((s2-1
+                  (vector-! (new 'stack-no-clear 'vector) (-> obj root-override2 gspot-pos) (-> obj root-override2 trans))
+                  )
+                )
+            (vector-normalize! s2-1 1.0)
+            (vector+float*! (-> s3-0 start-pos) (-> obj root-override2 gspot-pos) s2-1 -4096.0)
+            (vector-float*! (-> s3-0 move-dist) s2-1 8192.0)
+            )
+          (let ((v1-9 s3-0))
+            (set! (-> v1-9 radius) 8192.0)
+            (set! (-> v1-9 collide-with) arg1)
+            (set! (-> v1-9 ignore-process0) obj)
+            (set! (-> v1-9 ignore-process1) #f)
+            (set! (-> v1-9 ignore-pat) (-> obj root-override2 pat-ignore-mask))
+            (set! (-> v1-9 action-mask) (collide-action solid))
+            )
+          (fill-using-line-sphere *collide-cache* s3-0)
+          )
+        (let ((s4-1 (new 'stack-no-clear 'vector)))
+          (vector-reset! s4-1)
+          (dotimes (s3-1 (-> *collide-cache* num-tris))
+            (let* ((v1-15 (-> *collide-cache* tris s3-1))
+                   (s1-1 (vector-! (new 'stack-no-clear 'vector) (-> v1-15 vertex 1) (the-as vector (-> v1-15 vertex))))
+                   (s0-1 (vector-! (new 'stack-no-clear 'vector) (-> v1-15 vertex 2) (the-as vector (-> v1-15 vertex))))
+                   (s2-2 (new 'stack-no-clear 'vector))
+                   )
+              (vector-normalize! s1-1 1.0)
+              (vector-normalize! s0-1 1.0)
+              (vector-cross! s2-2 s1-1 s0-1)
+              (if (< (cos 10922.667) (vector-dot s2-2 *y-vector*))
+                  (vector+! s4-1 s4-1 s2-2)
+                  )
+              )
+            )
+          (vector-normalize-copy! (-> obj gspot-normal) s4-1 1.0)
+          )
+        (let ((f0-4 (-> obj root-override2 gspot-pos y)))
+          (if (= (-> obj y-level) -40959590.0)
+              (set! (-> obj y-level) f0-4)
+              (seek! (-> obj y-level) f0-4 (* 8192.0 (-> pp clock seconds-per-frame)))
+              )
+          )
+        (set! (-> obj root-override2 gspot-pos y) (-> obj y-level))
+        (set! (-> arg0 best-other-tri intersect y) (-> obj y-level))
+        #t
+        )
+      )
+    )
+  )
+
+;; definition for method 183 of type mammoth
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod mammoth-method-183 mammoth ((obj mammoth))
+  (with-pp
+    (cond
+      ((= (-> obj root-override2 gspot-pos y) -40959590.0)
+       (quaternion-copy! (-> obj tilt-quat) *unity-quaternion*)
+       )
+      (else
+        (let ((s1-0 (-> obj root-override2 trans))
+              (s5-0 (new 'stack-no-clear 'vector))
+              )
+          (set! (-> s5-0 quad) (-> obj gspot-normal quad))
+          (let ((s4-0 (new 'stack-no-clear 'vector)))
+            (set! (-> s4-0 quad) (-> obj gspot-normal quad))
+            (let ((s3-0 (new 'stack-no-clear 'vector)))
+              (set! (-> s3-0 quad) (-> obj gspot-normal quad))
+              (let ((s2-0 (new 'stack-no-clear 'vector)))
+                (set! (-> s2-0 quad) (-> obj gspot-normal quad))
+                (let ((s0-0 (lambda ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 vector))
+                              (let ((gp-1 (vector-! (new 'stack-no-clear 'vector) arg2 arg1))
+                                    (s4-1 (vector-! (new 'stack-no-clear 'vector) arg3 arg1))
+                                    )
+                                (vector-normalize! gp-1 1.0)
+                                (vector-normalize! s4-1 1.0)
+                                (vector-cross! arg0 s4-1 gp-1)
+                                )
+                              )
+                            )
+                      )
+                  (if (and (logtest? (-> obj foot-flags) 1) (logtest? (-> obj foot-flags) 2))
+                      (s0-0 s5-0 s1-0 (the-as vector (-> obj foot-pos)) (-> obj foot-pos 1))
+                      )
+                  (if (and (logtest? (-> obj foot-flags) 2) (logtest? (-> obj foot-flags) 4))
+                      (s0-0 s4-0 s1-0 (-> obj foot-pos 1) (-> obj foot-pos 2))
+                      )
+                  (if (and (logtest? (-> obj foot-flags) 4) (logtest? (-> obj foot-flags) 8))
+                      (s0-0 s4-0 s1-0 (-> obj foot-pos 2) (-> obj foot-pos 3))
+                      )
+                  (if (and (logtest? (-> obj foot-flags) 8) (logtest? (-> obj foot-flags) 1))
+                      (s0-0 s4-0 s1-0 (-> obj foot-pos 3) (the-as vector (-> obj foot-pos)))
+                      )
+                  )
+                (vector+! s5-0 s5-0 s4-0)
+                (vector+! s5-0 s5-0 s3-0)
+                (vector+! s5-0 s5-0 s2-0)
+                )
+              )
+            )
+          (vector-normalize! s5-0 1.0)
+          (let ((s4-1 (new 'stack-no-clear 'quaternion)))
+            (let ((s0-1 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat))))
+              (set! (-> s0-1 y) 0.0)
+              (vector-xz-normalize! s0-1 1.0)
+              (vector-rotate-y! s5-0 s5-0 (- (vector-y-angle s0-1)))
+              )
+            (quaternion-from-two-vectors-max-angle! s4-1 *up-vector* s5-0 4551.1113)
+            (quaternion-slerp! (-> obj tilt-quat) (-> obj tilt-quat) s4-1 (* 0.5 (-> pp clock seconds-per-frame)))
+            )
+          )
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+;; definition for function mammoth-joint-mod-tilt
+(defun mammoth-joint-mod-tilt ((arg0 cspace) (arg1 transformq))
+  (-> arg0 param1)
+  (cspace<-parented-transformq-joint! arg0 arg1)
+  (none)
+  )
+
+;; definition for function mammoth-joint-mod-heel
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch vector vs none.
+(defun mammoth-joint-mod-heel ((arg0 cspace) (arg1 transformq))
+  (let* ((s0-0 (-> arg0 param1))
+         (f30-0 (-> (the-as mammoth (+ (* (the-as int (-> arg0 param2)) 4) (the-as int s0-0))) heel-lerp 0))
+         (s3-0 (new 'stack-no-clear 'quaternion))
+         )
+    (cspace<-parented-transformq-joint! arg0 arg1)
+    (let ((s4-0 (new 'stack-no-clear 'vector))
+          (s5-0 (new 'stack-no-clear 'vector))
+          )
+      (let ((s2-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> (the-as mammoth s0-0) root-override2 quat)))
+            (s1-0 (new 'stack-no-clear 'vector))
+            )
+        (set! (-> s1-0 quad) (-> (the-as mammoth s0-0) my-up-vector quad))
+        (let ((v1-6 (-> arg0 param2)))
+          (cond
+            ((zero? v1-6)
+             (vector-negate! s1-0 s1-0)
+             )
+            ((= v1-6 1)
+             (vector-negate! s2-0 s2-0)
+             )
+            ((= v1-6 2)
+             (vector-negate! s1-0 s1-0)
+             )
+            ((= v1-6 3)
+             (vector-negate! s2-0 s2-0)
+             )
+            )
+          )
+        (let ((s2-1 (forward-up->quaternion (new 'stack-no-clear 'quaternion) s2-0 s1-0)))
+          (matrix->scale (-> arg0 bone transform) s4-0)
+          (set! (-> s5-0 quad) (-> arg0 bone transform trans quad))
+          (matrix-with-scale->quaternion s3-0 (-> arg0 bone transform))
+          (quaternion-normalize! s3-0)
+          (quaternion-slerp! s3-0 s2-1 s3-0 f30-0)
+          )
+        )
+      (quaternion->matrix (-> arg0 bone transform) s3-0)
+      (scale-matrix! (-> arg0 bone transform) s4-0 (-> arg0 bone transform))
+      (set! (-> arg0 bone transform trans quad) (-> s5-0 quad))
+      )
+    )
+  (none)
+  )
+
+;; definition for function mammoth-leg-ik-callback
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch none vs object.
+(defun mammoth-leg-ik-callback ((arg0 joint-mod-ik) (arg1 matrix) (arg2 matrix) (arg3 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 ((s5-0 (new 'stack-no-clear 'vector)))
+        (set! (-> s5-0 quad) (-> arg3 quad))
+        (let ((f30-0 (- (-> arg3 y) (-> arg0 process root trans y))))
+          (if (< 6144.0 f30-0)
+              (set! f30-0 6144.0)
+              )
+          (if (< f30-0 -6144.0)
+              (set! f30-0 -6144.0)
+              )
+          (let ((s2-0 (-> arg0 user-position)))
+            (let ((s3-0 (-> arg0 user-position)))
+              (let ((v1-14 (vector-y-quaternion! (new 'stack-no-clear 'vector) (-> arg0 process root quat))))
+                (let ((a0-2 f30-0))
+                  (.mov vf7 a0-2)
+                  )
+                (.lvf vf5 (&-> v1-14 quad))
+                )
+              (.lvf vf4 (&-> s3-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 (&-> s2-0 quad) vf6)
+            )
+          )
+        (let ((f0-4 (- (-> arg3 y) (-> arg0 user-position y))))
+          (seek! (-> arg0 user-float) f0-4 (* 40960.0 (-> pp clock seconds-per-frame)))
+          )
+        (let* ((f0-8 (-> arg0 user-float))
+               (f30-1 (lerp-scale 1.0 0.0 f0-8 0.0 12288.0))
+               (s3-1 (new 'stack-no-clear 'vector))
+               )
+          (let ((v1-17 s5-0))
+            (let ((a0-5 (-> arg0 user-normal)))
+              (let ((a1-5 8192.0))
+                (.mov vf7 a1-5)
+                )
+              (.lvf vf5 (&-> a0-5 quad))
+              )
+            (.lvf vf4 (&-> v1-17 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 (&-> s3-1 quad) vf6)
+          (vector-float*! (new 'stack-no-clear 'vector) (-> arg0 user-normal) -16384.0)
+          (let ((s4-1 (new 'stack-no-clear 'vector)))
+            0.0
+            (let ((f0-12 (intersect-ray-plane s3-1 (-> arg0 user-normal) (-> arg0 user-position) *up-vector*))
+                  (a0-8 s4-1)
+                  )
+              (let ((v1-20 (-> arg0 user-normal)))
+                (let ((a1-8 f0-12))
+                  (.mov vf7 a1-8)
+                  )
+                (.lvf vf5 (&-> v1-20 quad))
+                )
+              (.lvf vf4 (&-> s3-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 (&-> a0-8 quad) vf6)
+              )
+            (let ((a1-9 s4-1))
+              (let ((v1-21 s4-1))
+                (let ((a0-9 (-> arg0 user-normal)))
+                  (let ((a2-7
+                          (- (vector-dot (-> arg0 user-normal) (vector-! (new 'stack-no-clear 'vector) s4-1 (-> arg0 user-position))))
+                          )
+                        )
+                    (.mov vf7 a2-7)
+                    )
+                  (.lvf vf5 (&-> a0-9 quad))
+                  )
+                (.lvf vf4 (&-> v1-21 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-9 quad) vf6)
+              )
+            (let ((a1-10 s5-0))
+              (let ((v1-22 s5-0))
+                (let ((a0-11 (vector-! (new 'stack-no-clear 'vector) s4-1 s5-0)))
+                  (let ((a2-10 (fmin 1.0 (* (-> arg0 user-blend) f30-1))))
+                    (.mov vf7 a2-10)
+                    )
+                  (.lvf vf5 (&-> a0-11 quad))
+                  )
+                (.lvf vf4 (&-> v1-22 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-10 quad) vf6)
+              )
+            )
+          )
+        (the-as object (handle-copy! arg0 s5-0))
+        )
+      )
+    )
+  )
+
+;; definition for function mammoth-update-ik
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defbehavior mammoth-update-ik mammoth ()
+  (local-vars (sv-688 vector))
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         (vf7 :class vf)
+         )
+    (init-vf0-vector)
+    (let ((gp-0 (new 'stack-no-clear 'collide-query))
+          (s5-0 (-> self root-override2))
+          )
+      (dotimes (s4-0 4)
+        (let ((s3-0 (-> self joint-ik s4-0)))
+          #t
+          (set! (-> s3-0 callback) mammoth-leg-ik-callback)
+          (-> s3-0 shoulder-matrix-no-ik)
+          (let ((v1-5 (-> s3-0 elbow-matrix-no-ik))
+                (s0-0 (new 'stack-no-clear 'vector))
+                )
+            (set! sv-688 (new 'stack-no-clear 'vector))
+            (let ((a0-2 (-> *y-vector* quad)))
+              (set! (-> sv-688 quad) a0-2)
+              )
+            (let ((s2-0 (new 'stack-no-clear 'vector)))
+              (new 'stack-no-clear 'vector)
+              (new 'stack-no-clear 'vector)
+              (let ((s1-0 (new 'stack-no-clear 'vector)))
+                (let ((a1-1 s0-0))
+                  (let ((a0-5 (-> v1-5 trans)))
+                    (let ((v1-6 (-> v1-5 vector 1)))
+                      (let ((a2-0 (-> s3-0 hand-dist)))
+                        (.mov vf7 a2-0)
+                        )
+                      (.lvf vf5 (&-> v1-6 quad))
+                      )
+                    (.lvf vf4 (&-> a0-5 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-1 quad) vf6)
+                  )
+                (let ((a1-2 (-> gp-0 bbox))
+                      (v1-7 s0-0)
+                      (a0-6 (new 'stack-no-clear 'vector))
+                      )
+                  (set! (-> a0-6 x) 10240.0)
+                  (set! (-> a0-6 y) 14336.0)
+                  (set! (-> a0-6 z) 10240.0)
+                  (set! (-> a0-6 w) 1.0)
+                  (vector-! (the-as vector a1-2) v1-7 a0-6)
+                  )
+                (let ((a1-4 (-> gp-0 bbox max))
+                      (v1-8 s0-0)
+                      (a0-7 (new 'stack-no-clear 'vector))
+                      )
+                  (set! (-> a0-7 x) 10240.0)
+                  (set! (-> a0-7 y) 6144.0)
+                  (set! (-> a0-7 z) 10240.0)
+                  (set! (-> a0-7 w) 1.0)
+                  (vector+! a1-4 v1-8 a0-7)
+                  )
+                (set! (-> gp-0 collide-with) (collide-spec backgnd))
+                (set! (-> gp-0 ignore-process0) #f)
+                (set! (-> gp-0 ignore-process1) #f)
+                (fill-using-bounding-box *collide-cache* gp-0)
+                (let ((f0-11 (lerp-scale 1.0 0.0 (- (-> s0-0 y) (-> s5-0 gspot-pos y)) 2048.0 12288.0)))
+                  (seek! (-> s3-0 user-blend) f0-11 (* 4.0 (-> self clock seconds-per-frame)))
+                  )
+                (let ((a1-9 (-> gp-0 start-pos)))
+                  (let ((v1-14 s0-0))
+                    (let ((a0-11 sv-688))
+                      (let ((a2-12 12288.0))
+                        (.mov vf7 a2-12)
+                        )
+                      (.lvf vf5 (&-> a0-11 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-9 quad) vf6)
+                  )
+                (let ((v1-15 (-> gp-0 move-dist))
+                      (f0-16 -40960.0)
+                      )
+                  (vector-float*! v1-15 sv-688 f0-16)
+                  )
+                (let ((v1-17 gp-0))
+                  (set! (-> v1-17 radius) 4.096)
+                  (set! (-> v1-17 collide-with) (-> gp-0 collide-with))
+                  (set! (-> v1-17 ignore-process0) #f)
+                  (set! (-> v1-17 ignore-process1) #f)
+                  (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))
+                  )
+                (let ((f0-18 (probe-using-line-sphere *collide-cache* gp-0)))
+                  (cond
+                    ((>= f0-18 0.0)
+                     (set! (-> s1-0 quad) (-> gp-0 best-other-tri normal quad))
+                     (let ((a1-11 s2-0))
+                       (let ((v1-20 (-> gp-0 start-pos)))
+                         (let ((a0-21 (-> gp-0 move-dist)))
+                           (let ((a2-13 f0-18))
+                             (.mov vf7 a2-13)
+                             )
+                           (.lvf vf5 (&-> a0-21 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-11 quad) vf6)
+                       )
+                     (set! (-> s3-0 user-position quad) (-> s2-0 quad))
+                     (set! (-> s3-0 user-normal quad) (-> s1-0 quad))
+                     )
+                    (else
+                      (set! (-> s0-0 y) (-> self root-override2 trans y))
+                      (set! (-> s3-0 user-position quad) (-> s0-0 quad))
+                      (set! (-> s3-0 user-normal quad) (-> *y-vector* quad))
+                      )
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+;; definition for method 184 of type mammoth
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod mammoth-method-184 mammoth ((obj mammoth))
+  (with-pp
+    (rlet ((acc :class vf)
+           (vf0 :class vf)
+           (vf4 :class vf)
+           (vf5 :class vf)
+           (vf6 :class vf)
+           (vf7 :class vf)
+           )
+      (init-vf0-vector)
+      (dotimes (s5-0 4)
+        (-> obj joint-ik s5-0 shoulder-matrix-no-ik)
+        (let ((a0-1 (-> obj joint-ik s5-0 elbow-matrix-no-ik))
+              (s3-0 (-> *mammoth-ik-setup* s5-0))
+              (v1-8 (new 'stack-no-clear 'vector))
+              (s1-0 (new 'stack-no-clear 'vector))
+              )
+          (set! (-> s1-0 quad) (-> *y-vector* quad))
+          (new 'stack-no-clear 'vector)
+          (let ((s4-0 (new 'stack-no-clear 'vector)))
+            (let ((a2-0 v1-8))
+              (let ((a1-4 (-> a0-1 trans)))
+                (let ((a0-2 (-> a0-1 vector 1)))
+                  (let ((a3-0 (-> s3-0 hand-dist)))
+                    (.mov vf7 a3-0)
+                    )
+                  (.lvf vf5 (&-> a0-2 quad))
+                  )
+                (.lvf vf4 (&-> a1-4 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 (&-> a2-0 quad) vf6)
+              )
+            (set! (-> s4-0 quad) (-> v1-8 quad))
+            (let ((s2-0 (new 'stack-no-clear 'collide-query))
+                  (f30-0 (- (- (-> s4-0 y) (-> s3-0 ground-dist)) (-> obj root-override2 trans y)))
+                  )
+              (when #t
+                (let ((a1-5 (-> s2-0 bbox))
+                      (v1-13 s4-0)
+                      (a0-4 (new 'stack-no-clear 'vector))
+                      )
+                  (set! (-> a0-4 x) 16384.0)
+                  (set! (-> a0-4 y) 16384.0)
+                  (set! (-> a0-4 z) 16384.0)
+                  (set! (-> a0-4 w) 1.0)
+                  (vector-! (the-as vector a1-5) v1-13 a0-4)
+                  )
+                (let ((a1-7 (-> s2-0 bbox max))
+                      (v1-14 s4-0)
+                      (a0-5 (new 'stack-no-clear 'vector))
+                      )
+                  (set! (-> a0-5 x) 16384.0)
+                  (set! (-> a0-5 y) 16384.0)
+                  (set! (-> a0-5 z) 16384.0)
+                  (set! (-> a0-5 w) 1.0)
+                  (vector+! a1-7 v1-14 a0-5)
+                  )
+                (set! (-> s2-0 collide-with) (collide-spec backgnd))
+                (set! (-> s2-0 ignore-process0) #f)
+                (set! (-> s2-0 ignore-process1) #f)
+                (set! (-> s2-0 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+                (fill-using-bounding-box *collide-cache* s2-0)
+                (let ((a1-10 (-> s2-0 start-pos)))
+                  (let ((v1-19 s4-0))
+                    (let ((a0-7 s1-0))
+                      (let ((a2-10 24576.0))
+                        (.mov vf7 a2-10)
+                        )
+                      (.lvf vf5 (&-> a0-7 quad))
+                      )
+                    (.lvf vf4 (&-> v1-19 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-10 quad) vf6)
+                  )
+                (vector-float*! (-> s2-0 move-dist) s1-0 -49152.0)
+                (let ((v1-22 s2-0))
+                  (set! (-> v1-22 radius) (-> s3-0 ground-dist))
+                  (set! (-> v1-22 collide-with) (collide-spec backgnd))
+                  (set! (-> v1-22 ignore-process0) #f)
+                  (set! (-> v1-22 ignore-process1) #f)
+                  (set! (-> v1-22 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+                  (set! (-> v1-22 action-mask) (collide-action solid))
+                  )
+                (let ((f0-14 (probe-using-line-sphere *collide-cache* s2-0)))
+                  (when (>= f0-14 0.0)
+                    (let ((v1-26 (new 'stack-no-clear 'vector)))
+                      (let ((a0-13 (-> s2-0 start-pos)))
+                        (let ((a1-12 (-> s2-0 move-dist)))
+                          (let ((a2-11 f0-14))
+                            (.mov vf7 a2-11)
+                            )
+                          (.lvf vf5 (&-> a1-12 quad))
+                          )
+                        (.lvf vf4 (&-> a0-13 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-26 quad) vf6)
+                      (seek! (-> obj ik-handle-y s5-0) (-> v1-26 y) (* 16384.0 (-> pp clock seconds-per-frame)))
+                      )
+                    )
+                  )
+                (set! (-> s4-0 y) (+ (-> obj ik-handle-y s5-0) f30-0))
+                )
+              (set! (-> obj heel-lerp s5-0) (lerp-scale 0.0 1.0 f30-0 0.0 3072.0))
+              )
+            (handle-copy! (-> obj joint-ik s5-0) s4-0)
+            )
+          )
+        )
+      0
+      (none)
+      )
+    )
+  )
+
+;; definition for method 55 of type mammoth
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-55 mammoth ((obj mammoth))
+  (local-vars (sv-752 lightning-spec) (sv-768 int) (sv-784 symbol) (sv-800 mammoth))
+  (with-pp
+    (let ((t9-0 (method-of-type nav-enemy enemy-method-55)))
+      (t9-0 obj)
+      )
+    (mammoth-update-ik)
+    (dotimes (s5-0 4)
+      (enable-set! (-> obj joint-ik s5-0) (zero? (-> obj draw cur-lod)))
+      )
+    (when (!= (-> obj old-foot-flags) (-> obj foot-flags))
+      (let ((s5-1 (new 'static 'array uint32 4 #xa #xd #x1c #x19)))
+        (dotimes (s4-0 4)
+          (let ((s3-0 (vector<-cspace!
+                        (new 'stack-no-clear 'vector)
+                        (-> obj node-list data (-> (the-as (pointer int32) (&+ s5-1 (* s4-0 4)))))
+                        )
+                      )
+                (s2-0 (new 'stack-no-clear 'collide-query))
+                )
+            (when (logtest? (ash 1 s4-0) (-> obj foot-flags))
+              (when (not (logtest? (ash 1 s4-0) (-> obj old-foot-flags)))
+                (set! (-> s2-0 start-pos quad) (-> s3-0 quad))
+                (vector-reset! (-> s2-0 move-dist))
+                (set! (-> s2-0 start-pos y) (+ 8192.0 (-> s2-0 start-pos y)))
+                (set! (-> s2-0 move-dist y) -40960.0)
+                (let ((v1-27 s2-0))
+                  (set! (-> v1-27 radius) 2048.0)
+                  (set! (-> v1-27 collide-with) (-> obj enemy-info-override gnd-collide-with))
+                  (set! (-> v1-27 ignore-process0) obj)
+                  (set! (-> v1-27 ignore-process1) #f)
+                  (set! (-> v1-27 ignore-pat) (-> obj root-override2 pat-ignore-mask))
+                  (set! (-> v1-27 action-mask) (collide-action solid))
+                  )
+                (if (>= (fill-and-probe-using-line-sphere *collide-cache* s2-0) 0.0)
+                    (set! (-> s3-0 y) (-> s2-0 best-other-tri intersect y))
+                    )
+                (set! (-> obj foot-pos s4-0 quad) (-> s3-0 quad))
+                )
+              )
+            )
+          )
+        )
+      (set! (-> obj old-foot-flags) (-> obj foot-flags))
+      )
+    (dotimes (v1-37 4)
+      (when (logtest? (ash 1 v1-37) (-> obj foot-flags))
+        )
+      )
+    (when (and (< (- (-> pp clock frame-counter) (-> obj lightning-timer)) (seconds 3))
+               (< (-> obj lightning-attack-timer) (-> pp clock frame-counter))
+               )
+      (let ((s5-2 *target*))
+        (when s5-2
+          (let* ((v1-47 (get-trans s5-2 0))
+                 (s0-1 (vector-! (new 'stack-no-clear 'vector) v1-47 (-> obj root-override2 trans)))
+                 )
+            (when (< (vector-length s0-1) 57344.0)
+              (let ((s4-1 (new 'stack-no-clear 'event-message-block)))
+                (set! (-> s4-1 from) (process->ppointer pp))
+                (set! (-> s4-1 num-params) 2)
+                (set! (-> s4-1 message) 'attack)
+                (set! (-> s4-1 param 0) (the-as uint #f))
+                (let ((s3-1 (new 'static 'attack-info :mask (attack-info-mask vector shove-back shove-up control id))))
+                  (let* ((a0-38 *game-info*)
+                         (a1-12 (+ (-> a0-38 attack-id) 1))
+                         )
+                    (set! (-> a0-38 attack-id) a1-12)
+                    (set! (-> s3-1 id) a1-12)
+                    )
+                  (set! (-> s3-1 vector quad)
+                        (-> (vector-normalize! (vector-! (new 'stack-no-clear 'vector) v1-47 (-> obj root-override2 trans)) 1.0) quad)
+                        )
+                  (set! (-> s3-1 shove-back) 24576.0)
+                  (set! (-> s3-1 shove-up) 12288.0)
+                  (set! (-> s3-1 control) (if (logtest? (focus-status board) (-> s5-2 focus-status))
+                                              1.0
+                                              0.0
+                                              )
+                        )
+                  (set! (-> s4-1 param 1) (the-as uint s3-1))
+                  )
+                (send-event-function s5-2 s4-1)
+                )
+              (let ((s2-1 (vector-x-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
+                    (s1-0 *mammoth-lightning-joint-tbl*)
+                    (s4-2 (new 'stack-no-clear 'array 'uint32 4))
+                    (s3-2 0)
+                    )
+                (let ((f30-0 (vector-dot s0-1 s2-1)))
+                  (dotimes (s0-2 (-> s1-0 length))
+                    (let* ((v0-9 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data (-> s1-0 s0-2))))
+                           (f0-12 (vector-dot (vector-! (new 'stack-no-clear 'vector) v0-9 (-> obj root-override2 trans)) s2-1))
+                           )
+                      (when (or (and (< 0.0 f0-12) (< 0.0 f30-0)) (and (< f0-12 0.0) (< f30-0 0.0)))
+                        (set! (-> s4-2 s3-2) (the-as uint (-> s1-0 s0-2)))
+                        (+! s3-2 1)
+                        (if (>= s3-2 3)
+                            (goto cfg-60)
+                            )
+                        )
+                      )
+                    )
+                  )
+                (label cfg-60)
+                (let ((s2-2 (get-process *default-dead-pool* lightning-tracker #x4000)))
+                  (when s2-2
+                    (let ((t9-11 (method-of-type lightning-tracker activate)))
+                      (t9-11
+                        (the-as lightning-tracker s2-2)
+                        s5-2
+                        (symbol->string (-> lightning-tracker symbol))
+                        (the-as pointer #x70004000)
+                        )
+                      )
+                    (let ((s5-3 run-function-in-process)
+                          (s1-1 s2-2)
+                          (s0-3 lightning-tracker-init)
+                          )
+                      (set! sv-752 (-> *lightning-spec-id-table* 1))
+                      (set! sv-768 600)
+                      (set! sv-784 (the-as symbol #f))
+                      (set! sv-800 obj)
+                      (let ((t2-0 (-> (the-as (pointer int32) (&+ s4-2 (* (get-rand-int obj s3-2) 4)))))
+                            (t3-0 6)
+                            )
+                        ((the-as (function object object object object object object object object none) s5-3)
+                         s1-1
+                         s0-3
+                         sv-752
+                         sv-768
+                         sv-784
+                         sv-800
+                         t2-0
+                         t3-0
+                         )
+                        )
+                      )
+                    (-> s2-2 ppointer)
+                    )
+                  )
+                )
+              (set! (-> obj lightning-attack-timer)
+                    (+ (-> pp clock frame-counter) (the int (* 300.0 (get-rand-float-range obj 0.067 0.1))))
+                    )
+              )
+            )
+          )
+        )
+      )
+    (mammoth-method-183 obj)
+    0
+    (none)
+    )
+  )
+
+;; definition for method 60 of type mammoth
+(defmethod coin-flip? mammoth ((obj mammoth))
+  "@returns The result of a 50/50 RNG roll"
+  #f
+  )
+
+;; definition for method 7 of type mammoth
+;; WARN: Return type mismatch process-focusable vs mammoth.
+(defmethod relocate mammoth ((obj mammoth) (arg0 int))
+  (dotimes (v1-0 4)
+    (if (nonzero? (-> obj joint-ik v1-0))
+        (&+! (-> obj joint-ik v1-0) arg0)
+        )
+    )
+  (the-as
+    mammoth
+    ((the-as (function process-focusable int process-focusable) (find-parent-method mammoth 7)) obj arg0)
+    )
+  )
+
+;; definition for method 114 of type mammoth
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-114 mammoth ((obj mammoth))
+  "@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))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 11) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 12))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec enemy camera-blocker pusher))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak bot enemy player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set-vector! (-> s4-0 local-sphere) 0.0 24576.0 0.0 57344.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 enemy camera-blocker pusher))
+      (set! (-> v1-14 prim-core collide-with) (collide-spec jak bot enemy player-list))
+      (set! (-> v1-14 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set-vector! (-> v1-14 local-sphere) 0.0 24576.0 0.0 24576.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 enemy camera-blocker))
+      (set! (-> v1-16 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-16 transform-index) 3)
+      (set-vector! (-> v1-16 local-sphere) 0.0 4096.0 16384.0 16384.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 enemy camera-blocker))
+      (set! (-> v1-18 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-18 transform-index) 3)
+      (set-vector! (-> v1-18 local-sphere) 0.0 3072.0 -6144.0 16384.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 enemy camera-blocker))
+      (set! (-> v1-20 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-20 transform-index) 3)
+      (set-vector! (-> v1-20 local-sphere) 0.0 16384.0 12288.0 12288.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 enemy camera-blocker))
+      (set! (-> v1-22 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-22 transform-index) 7)
+      (set-vector! (-> v1-22 local-sphere) 0.0 0.0 0.0 8192.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 enemy camera-blocker))
+      (set! (-> v1-24 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-24 transform-index) 30)
+      (set-vector! (-> v1-24 local-sphere) 0.0 0.0 0.0 7168.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 enemy camera-blocker))
+      (set! (-> v1-26 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-26 transform-index) 31)
+      (set-vector! (-> v1-26 local-sphere) 0.0 0.0 0.0 5120.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 enemy camera-blocker))
+      (set! (-> v1-28 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-28 transform-index) 24)
+      (set-vector! (-> v1-28 local-sphere) 0.0 4096.0 0.0 6144.0)
+      )
+    (let ((v1-30 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-30 prim-core collide-as) (collide-spec enemy camera-blocker))
+      (set! (-> v1-30 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-30 transform-index) 27)
+      (set-vector! (-> v1-30 local-sphere) 0.0 -4096.0 0.0 6144.0)
+      )
+    (let ((v1-32 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-32 prim-core collide-as) (collide-spec enemy camera-blocker))
+      (set! (-> v1-32 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-32 transform-index) 9)
+      (set-vector! (-> v1-32 local-sphere) 0.0 4096.0 0.0 5734.4)
+      )
+    (let ((v1-34 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-34 prim-core collide-as) (collide-spec enemy camera-blocker))
+      (set! (-> v1-34 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set! (-> v1-34 transform-index) 12)
+      (set-vector! (-> v1-34 local-sphere) 0.0 -4096.0 0.0 5734.4)
+      )
+    (set! (-> s5-0 nav-radius) 24576.0)
+    (let ((v1-36 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-36 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-36 prim-core collide-with))
+      )
+    (set! (-> obj root-override2) s5-0)
+    )
+  0
+  (none)
+  )
+
+;; definition for method 115 of type mammoth
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-115 mammoth ((obj mammoth))
+  "@abstract"
+  (with-pp
+    (initialize-skeleton
+      obj
+      (the-as skeleton-group (art-group-get-by-name *level* "skel-mammoth" (the-as (pointer uint32) #f)))
+      (the-as pair 0)
+      )
+    (enemy-method-113 obj *mammoth-nav-enemy-info*)
+    (logclear! (-> obj mask) (process-mask actor-pause))
+    (set-vector! (-> obj root-override2 scale) 1.5 1.5 1.5 1.0)
+    (set! (-> obj y-level) -40959590.0)
+    (set! (-> obj foot-flags) (the-as uint 0))
+    (set! (-> obj old-foot-flags) (the-as uint 0))
+    (set! (-> obj attack-timer) (-> pp clock frame-counter))
+    (set! (-> obj spawn-timer) 0)
+    (set! (-> obj my-up-vector quad) (-> *y-vector* quad))
+    (quaternion-copy! (-> obj my-up-quat) *unity-quaternion*)
+    (set! (-> obj gspot-timer) 0)
+    (set! (-> obj gspot-normal quad) (-> *y-vector* quad))
+    (set! (-> obj align) (new 'process 'align-control obj))
+    (dotimes (s5-1 4)
+      (set! (-> obj joint-ik s5-1) (new
+                                     'process
+                                     'joint-mod-ik
+                                     obj
+                                     (-> *mammoth-ik-setup* s5-1 elbow-index)
+                                     (-> *mammoth-ik-setup* s5-1 hand-dist)
+                                     )
+            )
+      (set! (-> obj joint-ik s5-1 elbow-pole-vector-axis) (the-as uint 2))
+      (set! (-> obj joint-ik s5-1 elbow-rotation-axis) (the-as uint 0))
+      (set! (-> obj joint-ik 0 callback) mammoth-leg-ik-callback)
+      )
+    (logior! (-> obj joint-ik 1 flags) (joint-mod-ik-flags elbow-trans-neg))
+    (logior! (-> obj joint-ik 2 flags) (joint-mod-ik-flags elbow-trans-neg))
+    (logior! (-> obj joint-ik 0 flags) (joint-mod-ik-flags elbow-rot-neg))
+    (logior! (-> obj joint-ik 1 flags) (joint-mod-ik-flags elbow-rot-neg))
+    (set! (-> obj path) (new 'process 'path-control obj 'path 0.0 (-> obj entity) #f))
+    (set! (-> obj path-pos) 0.0)
+    (set! (-> obj path-index) 0)
+    (set! (-> obj path-index-dir) 1)
+    (logior! (-> obj path flags) (path-control-flag display draw-line draw-point draw-text))
+    (get-point-in-path! (-> obj path) (-> obj root-override2 trans) 0.0 'interp)
+    (set! (-> obj move-pos 0 quad) (-> obj root-override2 trans quad))
+    (set! (-> obj move-pos 1 quad) (-> obj root-override2 trans quad))
+    (forward-up-nopitch->quaternion
+      (-> obj root-override2 quat)
+      (vector-!
+        (new 'stack-no-clear 'vector)
+        (get-point-in-path! (-> obj path) (new 'stack-no-clear 'vector) (the float (+ (-> obj path-index) 1)) 'interp)
+        (-> obj root-override2 trans)
+        )
+      *up-vector*
+      )
+    (quaternion-copy! (-> obj tilt-quat) *unity-quaternion*)
+    (let ((a0-38 (-> obj node-list data 4)))
+      (set! (-> a0-38 param0) mammoth-joint-mod-tilt)
+      (set! (-> a0-38 param1) obj)
+      )
+    (let ((a0-39 (-> obj node-list data 10)))
+      (set! (-> a0-39 param0) mammoth-joint-mod-heel)
+      (set! (-> a0-39 param1) obj)
+      (set! (-> a0-39 param2) (the-as basic 0))
+      )
+    (let ((v1-61 (-> obj node-list data 13)))
+      (set! (-> v1-61 param0) mammoth-joint-mod-heel)
+      (set! (-> v1-61 param1) obj)
+      (set! (-> v1-61 param2) (the-as basic 1))
+      )
+    (let ((v1-63 (-> obj node-list data 25)))
+      (set! (-> v1-63 param0) mammoth-joint-mod-heel)
+      (set! (-> v1-63 param1) obj)
+      (set! (-> v1-63 param2) (the-as basic 2))
+      )
+    (let ((v1-65 (-> obj node-list data 28)))
+      (set! (-> v1-65 param0) mammoth-joint-mod-heel)
+      (set! (-> v1-65 param1) obj)
+      (set! (-> v1-65 param2) (the-as basic 3))
+      )
+    (dotimes (v1-66 4)
+      (set! (-> obj heel-lerp v1-66) 0.0)
+      )
+    (set! (-> obj lightning-timer) 0)
+    (set! (-> obj lightning-attack-timer) 0)
+    (set! (-> obj feet-ik-init-timer) (-> pp clock frame-counter))
+    (logclear! (-> obj enemy-flags) (enemy-flag check-water-backup))
+    0
+    (none)
+    )
+  )
diff --git a/test/decompiler/reference/jak2/levels/nest/mantis_REF.gc b/test/decompiler/reference/jak2/levels/nest/mantis_REF.gc
new file mode 100644
index 0000000000..77ab431039
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/nest/mantis_REF.gc
@@ -0,0 +1,2106 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; failed to figure out what this is:
+(defpartgroup group-mantis-dust-puff
+  :id 1221
+  :duration (seconds 0.017)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 8)
+  :parts ((sp-item 5221))
+  )
+
+;; failed to figure out what this is:
+(defpart 5221
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 6.0)
+    (sp-rnd-flt spt-scale-x (meters 0.6) (meters 0.4) 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 8.0 1.0)
+    (sp-rnd-flt spt-g 16.0 8.0 1.0)
+    (sp-rnd-flt spt-b 16.0 8.0 1.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.01) (meters 0.0026666666) 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-r -0.35555556)
+    (sp-flt spt-fade-g -0.35555556)
+    (sp-flt spt-fade-b -0.35555556)
+    (sp-flt spt-fade-a -0.30476192)
+    (sp-flt spt-accel-y -1.3653333)
+    (sp-int spt-timer 120)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int spt-next-time 60)
+    (sp-launcher-by-id spt-next-launcher 642)
+    (sp-rnd-flt spt-conerot-x (degrees 60.0) (degrees 30.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 180.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpartgroup group-mantis-birth-nest
+  :id 1222
+  :duration (seconds 7.335)
+  :linger-duration (seconds 4)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 3 0 8)
+  :parts ((sp-item 5224 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 250 :binding 5222)
+    (sp-item 5224 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 200 :binding 5222)
+    (sp-item 5224 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 150 :binding 5222)
+    (sp-item 5224 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 100 :binding 5222)
+    (sp-item 5225 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 120 :binding 5223)
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5223 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5222 :flags (bit1 start-dead))
+    (sp-item 5226 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 320)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 5224
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x3 :page #xd15))
+    (sp-func spt-birth-func 'birth-func-texture-group)
+    (sp-rnd-flt spt-num 0.1 0.5 1.0)
+    (sp-rnd-flt spt-x (meters 0) (meters 1) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 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.1) 1.0)
+    (sp-rnd-flt spt-r 200.0 55.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.06666667) (meters 0.033333335) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -1.2) (degrees 2.4) 1.0)
+    (sp-rnd-flt spt-accel-y -8.192 -8.192 1.0)
+    (sp-flt spt-friction 0.98)
+    (sp-int spt-timer 350)
+    (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 -783285504 -783285248 -783284992 -783284736 -783284480)
+      )
+    (sp-func spt-func 'check-drop-level-mantis-dirt-rubble-nest)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 15.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-flt spt-conerot-radius (meters 0.1))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 5223
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.0 0.2 1.0)
+    (sp-sound (static-sound-spec "debris-fall" :num 0.01 :volume 100.0))
+    (sp-rnd-flt spt-scale-x (meters 0.3) (meters 0.1) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 1) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-r 160.0 16.0 1.0)
+    (sp-rnd-flt spt-g 130.0 32.0 1.0)
+    (sp-rnd-flt spt-b 110.0 16.0 1.0)
+    (sp-rnd-flt spt-a 16.0 16.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0) (meters -0.0033333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.0033333334) (meters 0.0016666667) 1.0)
+    (sp-rnd-flt spt-scalevel-y (meters 0) (meters 0.00033333333) 1.0)
+    (sp-rnd-flt spt-fade-a -0.042666666 -0.064 1.0)
+    (sp-rnd-flt spt-accel-y -1.3653333 -1.3653333 1.0)
+    (sp-int spt-timer 250)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'check-drop-group-center)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 5222
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.0 0.2 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.3) (meters 0.1) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 1) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-r 160.0 16.0 1.0)
+    (sp-rnd-flt spt-g 130.0 32.0 1.0)
+    (sp-rnd-flt spt-b 110.0 16.0 1.0)
+    (sp-rnd-flt spt-a 16.0 16.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0) (meters -0.0033333334) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.0033333334) (meters 0.0016666667) 1.0)
+    (sp-rnd-flt spt-scalevel-y (meters 0) (meters 0.00033333333) 1.0)
+    (sp-rnd-flt spt-fade-a -0.042666666 -0.064 1.0)
+    (sp-rnd-flt spt-accel-y -1.3653333 -1.3653333 1.0)
+    (sp-int spt-timer 750)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-func spt-func 'check-drop-group-center)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 5226
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 1.0 1.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (meters 0.5) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 1) (meters 0.5) 1.0)
+    (sp-rnd-flt spt-r 160.0 16.0 1.0)
+    (sp-rnd-flt spt-g 130.0 32.0 1.0)
+    (sp-rnd-flt spt-b 110.0 16.0 1.0)
+    (sp-rnd-flt spt-a 16.0 48.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.026666667) (meters 0.026666667) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.006666667) (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.85 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 0.0) (degrees 90.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 0.5) 1.0)
+    )
+  )
+
+;; definition of type mantis-jump-info
+(deftype mantis-jump-info (structure)
+  ((distance    float          :offset-assert   0)
+   (search-step uint32         :offset-assert   4)
+   (destination vector :inline :offset-assert  16)
+   (direction   uint16         :offset-assert  32)
+   (start-anim  uint32         :offset-assert  36)
+   (air-anim    uint32         :offset-assert  40)
+   (land-anim   uint32         :offset-assert  44)
+   )
+  :method-count-assert 9
+  :size-assert         #x30
+  :flag-assert         #x900000030
+  )
+
+;; definition for method 3 of type mantis-jump-info
+(defmethod inspect mantis-jump-info ((obj mantis-jump-info))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'mantis-jump-info)
+  (format #t "~1Tdistance: ~f~%" (-> obj distance))
+  (format #t "~1Tsearch-step: ~D~%" (-> obj search-step))
+  (format #t "~1Tdestination: #<vector @ #x~X>~%" (-> obj destination))
+  (format #t "~1Tdirection: ~D~%" (-> obj direction))
+  (format #t "~1Tstart-anim: ~D~%" (-> obj start-anim))
+  (format #t "~1Tair-anim: ~D~%" (-> obj air-anim))
+  (format #t "~1Tland-anim: ~D~%" (-> obj land-anim))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type mantis
+(deftype mantis (nav-enemy)
+  ((base-height  float                    :offset-assert 604)
+   (flags        mantis-flag              :offset-assert 608)
+   (attack-timer time-frame               :offset-assert 616)
+   (track-timer  time-frame               :offset-assert 624)
+   (gspot-timer  time-frame               :offset-assert 632)
+   (gspot-normal vector           :inline :offset-assert 640)
+   (my-up-vector vector           :inline :offset-assert 656)
+   (jump         mantis-jump-info :inline :offset-assert 672)
+   )
+  :heap-base #x250
+  :method-count-assert 195
+  :size-assert         #x2d0
+  :flag-assert         #xc3025002d0
+  (:methods
+    (crawl () _type_ :state 178)
+    (attack0 () _type_ :state 179)
+    (attack1 () _type_ :state 180)
+    (ambush-crawling () _type_ :state 181)
+    (ambush-jumping () _type_ :state 182)
+    (mantis-method-183 () none 183)
+    (roll-right () _type_ :state 184)
+    (roll-left () _type_ :state 185)
+    (hop-away () _type_ :state 186)
+    (mantis-method-187 (_type_) none 187)
+    (mantis-method-188 (_type_) none 188)
+    (mantis-method-189 (_type_ vector vector) symbol 189)
+    (mantis-method-190 (_type_ vector vector) none 190)
+    (mantis-method-191 (_type_ vector vector) int 191)
+    (mantis-method-192 (_type_ vector vector) none 192)
+    (mantis-method-193 (_type_ vector) none 193)
+    (mantis-method-194 (_type_) symbol 194)
+    )
+  )
+
+;; definition for method 3 of type mantis
+(defmethod inspect mantis ((obj mantis))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-8)
+    )
+  (let ((t9-0 (method-of-type nav-enemy inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tbase-height: ~f~%" (-> obj base-height))
+  (format #t "~2Tflags: #x~X : (mantis-flag " (-> obj flags))
+  (let ((s5-0 (-> obj flags)))
+    (if (= (logand s5-0 (mantis-flag attack1-enabled)) (mantis-flag attack1-enabled))
+        (format #t "attack1-enabled ")
+        )
+    (if (= (logand s5-0 (mantis-flag tracked)) (mantis-flag tracked))
+        (format #t "tracked ")
+        )
+    )
+  (format #t ")~%")
+  (format #t "~2Tattack-timer: ~D~%" (-> obj attack-timer))
+  (format #t "~2Ttrack-timer: ~D~%" (-> obj track-timer))
+  (format #t "~2Tgspot-timer: ~D~%" (-> obj gspot-timer))
+  (format #t "~2Tgspot-normal: #<vector @ #x~X>~%" (-> obj gspot-normal))
+  (format #t "~2Tmy-up-vector: #<vector @ #x~X>~%" (-> obj my-up-vector))
+  (format #t "~2Tjump: #<mantis-jump-info @ #x~X>~%" (-> obj jump))
+  (label cfg-8)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-mantis mantis mantis-lod0-jg mantis-idle0-ja
+              ((mantis-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 1.5 0 4)
+              :shadow mantis-shadow-mg
+              )
+
+;; definition for symbol *mantis-nav-enemy-info*, type nav-enemy-info
+(define *mantis-nav-enemy-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #f
+    :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 idle-control-frame 8
+      (new 'static 'idle-control-frame :command (ic-cmd push) :param0 #x1e)
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x5 :param0 #x2 :param1 #x5)
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x7 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x6 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x8 :param0 #x1 :param1 #x1)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      (new 'static 'idle-control-frame)
+      )
+    :idle-anim 5
+    :notice-anim 5
+    :hostile-anim 9
+    :hit-anim 5
+    :knocked-anim 10
+    :knocked-land-anim 11
+    :die-anim 26
+    :die-falling-anim -1
+    :victory-anim 5
+    :jump-wind-up-anim -1
+    :jump-in-air-anim -1
+    :jump-land-anim -1
+    :neck-joint -1
+    :sound-hit (static-sound-name "mantis-hit")
+    :sound-die (static-sound-name "mantis-die")
+    :notice-distance (meters 50)
+    :notice-distance-delta (meters 10)
+    :proximity-notice-distance (meters 2)
+    :default-hit-points 2
+    :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
+    :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher)
+    :jump-height-min (meters 3)
+    :jump-height-factor 0.3
+    :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 106496.0
+    :knocked-red-vxz-hi 106496.0
+    :knocked-red-vy-lo 55296.0
+    :knocked-red-vy-hi 55296.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 7
+    :gem-seg #x2
+    :gem-no-seg #x4
+    :gem-offset (new 'static 'sphere :y 1286.144 :z 122.88 :r 327680.0)
+    :callback-info #f
+    :use-momentum #f
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #t
+    :use-pacing #t
+    :walk-anim 9
+    :turn-anim 5
+    :run-anim 9
+    :taunt-anim -1
+    :run-travel-speed (meters 6)
+    :run-acceleration (meters 1)
+    :run-turning-acceleration (meters 50)
+    :walk-travel-speed (meters 3)
+    :walk-acceleration (meters 1)
+    :walk-turning-acceleration (meters 20)
+    :maximum-rotation-rate (degrees 720.0)
+    :notice-nav-radius (meters 1)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 4)
+    :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! (-> *mantis-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+;; failed to figure out what this is:
+(defstate active (mantis)
+  :virtual #t
+  :trans (behavior ()
+    (let ((t9-1 (-> (the-as (state enemy) (find-parent-method mantis 32)) trans)))
+      (if t9-1
+          (t9-1)
+          )
+      )
+    (if (logtest? (-> self flags) (mantis-flag tracked))
+        (mantis-method-187 self)
+        )
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (until #f
+      (let ((gp-0 (get-rand-int-range self 3 5)))
+        (dotimes (s5-0 gp-0)
+          (ja-no-eval :group! mantis-idle0-ja
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-idle0-ja) frames num-frames) -1)))
+                      :frame-num 0.0
+                      )
+          (until (ja-done? 0)
+            (suspend)
+            (ja :num! (seek!))
+            )
+          )
+        )
+      (ja-no-eval :group! mantis-idle0-to-idle1-ja
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-idle0-to-idle1-ja) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      (let ((gp-1 (get-rand-int self 3)))
+        (dotimes (s5-1 gp-1)
+          (ja-no-eval :group! mantis-idle1-ja
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-idle1-ja) frames num-frames) -1)))
+                      :frame-num 0.0
+                      )
+          (until (ja-done? 0)
+            (suspend)
+            (ja :num! (seek!))
+            )
+          )
+        )
+      (ja-no-eval :group! mantis-idle1-to-idle0-ja
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-idle1-to-idle0-ja) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior mantis) nav-enemy-face-focus-post)
+  )
+
+;; failed to figure out what this is:
+(defstate ambush (mantis)
+  :virtual #t
+  :enter (behavior ()
+    (when (logtest? (-> self enemy-flags) (enemy-flag auto-reset-penetrate))
+      (logclear! (-> self enemy-flags) (enemy-flag auto-reset-penetrate))
+      (let ((gp-0 (-> self on-notice)))
+        (if gp-0
+            (eval!
+              (new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans))
+              (the-as pair gp-0)
+              )
+            )
+        )
+      )
+    (let ((v1-12 (-> self root-override2 root-prim)))
+      (set! (-> v1-12 prim-core collide-as) (collide-spec))
+      (set! (-> v1-12 prim-core collide-with) (collide-spec))
+      )
+    0
+    (let ((gp-1 (new 'stack-no-clear 'collide-query)))
+      (if (enemy-method-126 self gp-1 (-> self root-override2 trans) (collide-spec backgnd) 8192.0 81920.0 1024.0)
+          (set! (-> self base-height) (-> gp-1 best-other-tri intersect y))
+          (set! (-> self base-height) (-> self root-override2 trans y))
+          )
+      )
+    (let* ((gp-2 *target*)
+           (a0-5 (if (type? gp-2 process-focusable)
+                     gp-2
+                     )
+                 )
+           )
+      (when a0-5
+        (let* ((gp-3 (-> self root-override2))
+               (s3-0 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) (get-trans a0-5 0) (-> gp-3 trans)) 1.0))
+               (f0-2 (deg-diff (quaternion-y-angle (-> gp-3 quat)) (vector-y-angle s3-0)))
+               )
+          (quaternion-rotate-y! (-> gp-3 quat) (-> gp-3 quat) f0-2)
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((gp-0 (new 'stack-no-clear 'vector)))
+      (set! (-> gp-0 quad) (-> self root-override2 trans quad))
+      (set! (-> gp-0 y) (+ -18841.6 (-> 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-2 s5-0)
+                (a1-2 part-tracker-init)
+                (a2-4 (-> *part-group-id-table* 1222))
+                (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-2
+             a1-2
+             a2-4
+             a3-1
+             t0-0
+             t1-0
+             t2-0
+             t3-0
+             )
+            )
+          (-> s5-0 ppointer)
+          )
+        )
+      )
+    (let ((gp-1 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-1) (seconds 0.6))
+        (suspend)
+        )
+      )
+    (logior! (-> self draw status) (draw-control-status no-draw))
+    (let ((gp-2 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-2) (the int (* 300.0 (get-rand-float-range self 0.0 0.6))))
+        (suspend)
+        )
+      )
+    (logclear! (-> self draw status) (draw-control-status no-draw))
+    (if (rng-hit? self 0.5)
+        (go-virtual ambush-jumping)
+        (go-virtual ambush-crawling)
+        )
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate ambush-crawling (mantis)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior mantis) enemy-event-handler)
+  :code (behavior ()
+    (enemy-method-109 self 1)
+    (set! (-> self root-override2 trans y) (-> self base-height))
+    (ja-channel-push! 1 0)
+    (ja-no-eval :group! mantis-ground-crawl-out-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-ground-crawl-out-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (let ((v1-28 (-> self root-override2 root-prim)))
+      (set! (-> v1-28 prim-core collide-as) (-> self root-override2 backup-collide-as))
+      (set! (-> v1-28 prim-core collide-with) (-> self root-override2 backup-collide-with))
+      )
+    (go-virtual hostile)
+    (none)
+    )
+  :post (the-as (function none :behavior mantis) nav-enemy-simple-post)
+  )
+
+;; failed to figure out what this is:
+(defstate ambush-jumping (mantis)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior mantis) enemy-event-handler)
+  :enter (behavior ()
+    (let ((v1-0 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-0 enemy-flags)))
+          (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-0 enemy-flags))))
+          )
+      (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-0 enemy-flags))))
+      (set! (-> v1-0 nav callback-info) (-> v1-0 enemy-info-override callback-info))
+      )
+    0
+    (let ((v1-3 self))
+      (set! (-> v1-3 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-3 enemy-flags))))
+      )
+    0
+    (enemy-method-109 self 1)
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self root-override2 trans y) (+ -18841.6 (-> self base-height)))
+    (let ((gp-0 (-> self root-override2)))
+      (let ((v1-11 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> gp-0 quat))))
+        (vector-reset! (-> gp-0 transv))
+        (set! (-> v1-11 y) 0.0)
+        )
+      (vector-reset! (-> gp-0 transv))
+      (set! (-> gp-0 transv y) (* 4096.0 (get-rand-float-range self 28.0 32.0)))
+      )
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja-no-eval :group! mantis-ground-jump-out-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-ground-jump-out-ja) frames num-frames) -1)))
+                )
+    (until #f
+      (if (< (-> self base-height) (-> self root-override2 trans y))
+          (goto cfg-5)
+          )
+      (suspend)
+      (ja :num! (seek!))
+      )
+    #f
+    (until #f
+      (label cfg-5)
+      (when (< (+ 819.2 (-> self base-height)) (-> self root-override2 trans y))
+        (let ((v1-32 (-> self root-override2 root-prim)))
+          (set! (-> v1-32 prim-core collide-as) (-> self root-override2 backup-collide-as))
+          (set! (-> v1-32 prim-core collide-with) (-> self root-override2 backup-collide-with))
+          )
+        (goto cfg-9)
+        )
+      (suspend)
+      (ja :num! (seek!))
+      )
+    #f
+    (until #f
+      (label cfg-9)
+      (if (or (and (>= (fabs (* 4096.0 (-> self clock seconds-per-frame))) (-> self root-override2 transv y))
+                   (>= (-> self base-height) (-> self root-override2 trans y))
+                   )
+              (logtest? (-> self root-override2 status) (collide-status on-ground))
+              )
+          (goto cfg-24)
+          )
+      (suspend)
+      (if (not (ja-done? 0))
+          (ja :num! (seek!))
+          )
+      )
+    #f
+    (label cfg-24)
+    (ja-channel-push! 1 (seconds 0.05))
+    (ja-no-eval :group! mantis-ground-jump-out-land-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-ground-jump-out-land-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 1))
+        (if (logtest? (-> self root-override2 status) (collide-status on-ground))
+            (goto cfg-32)
+            )
+        (suspend)
+        )
+      )
+    (label cfg-32)
+    (go-virtual hostile)
+    (none)
+    )
+  :post (the-as (function none :behavior mantis) nav-enemy-falling-post)
+  )
+
+;; failed to figure out what this is:
+(defstate hostile (mantis)
+  :virtual #t
+  :exit (behavior ()
+    (logclear! (-> self flags) (mantis-flag attack1-enabled))
+    (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)
+      (let ((t9-0 (-> (method-of-type nav-enemy hostile) trans)))
+        (if t9-0
+            (t9-0)
+            )
+        )
+      (let ((gp-0 (handle->process (-> self focus handle))))
+        (when gp-0
+          (let* ((s4-0 (-> self focus-pos))
+                 (s5-1 (vector-! (new 'stack-no-clear 'vector) s4-0 (-> self root-override2 trans)))
+                 )
+            (let ((s2-1 (vector-z-quaternion! (new 'stack-no-clear 'vector) (get-quat (the-as process-focusable gp-0) 0)))
+                  (s1-0 s5-1)
+                  )
+              (let ((s3-1 s5-1))
+                (let ((v1-14 (* 2.0 (vector-length (get-transv (the-as process-focusable gp-0))))))
+                  (.mov vf7 v1-14)
+                  )
+                (.lvf vf5 (&-> s2-1 quad))
+                (.lvf vf4 (&-> s3-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 (&-> s1-0 quad) vf6)
+              )
+            (let ((f30-1 (vector-length s5-1)))
+              (when (not (logtest? (-> self flags) (mantis-flag tracked)))
+                (cond
+                  ((< (- (-> self clock frame-counter) (-> self attack-timer)) (seconds 5))
+                   (if (and (< 73728.0 f30-1) (mantis-method-194 self))
+                       (go-virtual crawl)
+                       )
+                   )
+                  ((< 40960.0 f30-1)
+                   (mantis-method-190 self (the-as vector gp-0) s5-1)
+                   )
+                  )
+                )
+              (when (and (and gp-0
+                              (zero? (logand (-> (the-as process-focusable gp-0) focus-status) (focus-status disable dead ignore grabbed)))
+                              )
+                         (and (>= (- (-> self clock frame-counter) (-> self attack-timer)) (seconds 5))
+                              (enemy-method-95 self s4-0 8192.0)
+                              (< f30-1 32768.0)
+                              )
+                         )
+                (cond
+                  ((< 24576.0 f30-1)
+                   (if (logtest? (-> self flags) (mantis-flag attack1-enabled))
+                       (go-virtual attack1)
+                       )
+                   )
+                  ((< 16384.0 f30-1)
+                   (go-virtual attack0)
+                   )
+                  )
+                )
+              )
+            (if (enemy-method-95 self s4-0 10922.667)
+                (mantis-method-187 self)
+                )
+            (if (logtest? (-> self flags) (mantis-flag tracked))
+                (mantis-method-192 self (the-as vector gp-0) s5-1)
+                (mantis-method-191 self (the-as vector gp-0) s5-1)
+                )
+            )
+          )
+        )
+      (none)
+      )
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate crawl (mantis)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior mantis) enemy-event-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (change-to (nav-mesh-from-res-tag (-> self entity) 'nav-mesh-actor 1) self)
+    (nav-enemy-method-166 self)
+    (let ((v1-6 (-> self nav)))
+      (set! (-> v1-6 max-rotation-rate) 21845.334)
+      )
+    0
+    (none)
+    )
+  :exit (behavior ()
+    (change-to (nav-mesh-from-res-tag (-> self entity) 'nav-mesh-actor 0) self)
+    (let ((v1-2 (-> self nav)))
+      (set! (-> v1-2 max-rotation-rate) (-> self enemy-info-override maximum-rotation-rate))
+      )
+    0
+    (none)
+    )
+  :trans (behavior ()
+    (nav-enemy-method-160 self)
+    (if (logtest? (-> self flags) (mantis-flag tracked))
+        (go-virtual hostile)
+        )
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (ja-channel-push! 1 (seconds 0.3))
+      (let ((v1-0 self))
+        (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logclear (-> v1-0 enemy-flags) (enemy-flag enemy-flag36))))
+        (set! (-> v1-0 nav callback-info) *nav-enemy-null-callback-info*)
+        )
+      0
+      (dotimes (gp-0 (get-rand-int-range self 1 2))
+        (ja-no-eval :group! mantis-idle0-ja
+                    :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-idle0-ja) frames num-frames) -1)))
+                    :frame-num 0.0
+                    )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek!))
+          )
+        )
+      (let ((gp-1 (handle->process (-> self focus handle))))
+        (cond
+          ((or (not gp-1) (< (the-as int (-> self focus aware)) 1))
+           (go-virtual idle)
+           )
+          (else
+            (let* ((s5-0 (-> self root-override2 trans))
+                   (s4-1 (vector-! (new 'stack-no-clear 'vector) (-> self focus-pos) s5-0))
+                   (s0-0 (vector-x-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat)))
+                   (s2-0 (new 'stack-no-clear 'vector))
+                   (s3-0 (new 'stack-no-clear 'vector))
+                   )
+              (let ((f30-1 (* 4096.0 (get-rand-float-range self 8.0 12.0)))
+                    (s1-0 (cloest-point-on-mesh (-> self nav) s5-0 s5-0 (the-as nav-poly #f)))
+                    )
+                (vector-normalize-copy! s2-0 s4-1 1.0)
+                (vector-rotate-around-y! s2-0 s2-0 (if (< 0.0 (vector-dot s2-0 s0-0))
+                                                       -16384.0
+                                                       16384.0
+                                                       )
+                                         )
+                (vector-float*! s3-0 s2-0 f30-1)
+                (clamp-vector-to-mesh-cross-gaps
+                  (-> self nav)
+                  s5-0
+                  s1-0
+                  s3-0
+                  204.8
+                  #f
+                  (the-as clamp-travel-vector-to-mesh-return-info #f)
+                  )
+                (when (< (vector-length s3-0) (+ -819.2 f30-1))
+                  (vector-float*! s3-0 s2-0 (- f30-1))
+                  (clamp-vector-to-mesh-cross-gaps
+                    (-> self nav)
+                    s5-0
+                    s1-0
+                    s3-0
+                    204.8
+                    #f
+                    (the-as clamp-travel-vector-to-mesh-return-info #f)
+                    )
+                  (if (< (vector-length s3-0) (+ -819.2 f30-1))
+                      (mantis-method-190 self (the-as vector gp-1) s4-1)
+                      )
+                  )
+                )
+              (vector+! (-> self move-dest) s5-0 s3-0)
+              )
+            (let ((a0-21 (-> self nav state))
+                  (v1-70 (-> self move-dest))
+                  )
+              (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-70 quad))
+              )
+            0
+            )
+          )
+        )
+      (ja-channel-push! 1 (seconds 0.3))
+      (let ((v1-73 self))
+        (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-73 enemy-flags)))
+            (set! (-> v1-73 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-73 enemy-flags))))
+            )
+        (set! (-> v1-73 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-73 enemy-flags))))
+        (set! (-> v1-73 nav callback-info) (-> v1-73 enemy-info-override callback-info))
+        )
+      0
+      (dotimes (gp-2 (get-rand-int-range self 3 5))
+        (ja-no-eval :group! mantis-run0-ja
+                    :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-run0-ja) frames num-frames) -1)))
+                    :frame-num 0.0
+                    )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek!))
+          )
+        (if (and (>= (- (-> self clock frame-counter) (-> self attack-timer)) (seconds 5))
+                 (< 1 (the-as int (-> self focus aware)))
+                 )
+            (go-virtual hostile)
+            )
+        (if (< (vector-vector-xz-distance (-> self root-override2 trans) (-> self move-dest)) 13107.2)
+            (goto cfg-38)
+            )
+        )
+      (label cfg-38)
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior mantis) nav-enemy-travel-post)
+  )
+
+;; failed to figure out what this is:
+(defstate attack0 (mantis)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior mantis) enemy-event-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (let ((v1-2 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-2 enemy-flags)))
+          (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-2 enemy-flags))))
+          )
+      (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-2 enemy-flags))))
+      (set! (-> v1-2 nav callback-info) (-> v1-2 enemy-info-override callback-info))
+      )
+    0
+    (set! (-> self attack-timer) (-> self clock frame-counter))
+    (none)
+    )
+  :exit (behavior ()
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (none)
+    )
+  :code (behavior ()
+    (logior! (-> self focus-status) (focus-status dangerous))
+    (let ((v1-2 (-> self nav)))
+      (set! (-> v1-2 target-speed) 81920.0)
+      )
+    0
+    (ja-no-eval :group! mantis-attack0-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-attack0-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (let ((v1-34 self))
+      (set! (-> v1-34 enemy-flags) (the-as enemy-flag (logclear (-> v1-34 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-34 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (ja-no-eval :group! mantis-attack0-land-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-attack0-land-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (nav-enemy-method-166 self)
+    (let ((v1-63 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-63 enemy-flags)))
+          (set! (-> v1-63 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-63 enemy-flags))))
+          )
+      (set! (-> v1-63 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-63 enemy-flags))))
+      (set! (-> v1-63 nav callback-info) (-> v1-63 enemy-info-override callback-info))
+      )
+    0
+    (go-hostile self)
+    (none)
+    )
+  :post (the-as (function none :behavior mantis) nav-enemy-chase-post)
+  )
+
+;; failed to figure out what this is:
+(defstate attack1 (mantis)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior mantis) enemy-event-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self attack-timer) (-> self clock frame-counter))
+    (none)
+    )
+  :exit (behavior ()
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (none)
+    )
+  :code (behavior ()
+    (let ((v1-0 self))
+      (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logclear (-> v1-0 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-0 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (ja-no-eval :group! mantis-attack1-wind-up-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-attack1-wind-up-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (let ((a0-5 (handle->process (-> self focus handle))))
+        (if a0-5
+            (seek-to-point-toward-point!
+              (-> self root-override2)
+              (get-trans (the-as process-focusable a0-5) 0)
+              (-> self nav max-rotation-rate)
+              (seconds 0.02)
+              )
+            )
+        )
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (let ((v1-36 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-36 enemy-flags)))
+          (set! (-> v1-36 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-36 enemy-flags))))
+          )
+      (set! (-> v1-36 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-36 enemy-flags))))
+      (set! (-> v1-36 nav callback-info) (-> v1-36 enemy-info-override callback-info))
+      )
+    0
+    (logior! (-> self focus-status) (focus-status dangerous))
+    (let ((v1-41 (-> self nav)))
+      (set! (-> v1-41 target-speed) 286720.0)
+      )
+    0
+    (ja-no-eval :group! mantis-attack1-go-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-attack1-go-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (let ((v1-73 self))
+      (set! (-> v1-73 enemy-flags) (the-as enemy-flag (logclear (-> v1-73 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-73 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (ja-no-eval :group! mantis-attack1-land-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-attack1-land-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (nav-enemy-method-166 self)
+    (let ((v1-102 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-102 enemy-flags)))
+          (set! (-> v1-102 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-102 enemy-flags))))
+          )
+      (set! (-> v1-102 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-102 enemy-flags))))
+      (set! (-> v1-102 nav callback-info) (-> v1-102 enemy-info-override callback-info))
+      )
+    0
+    (go-hostile self)
+    (none)
+    )
+  :post (the-as (function none :behavior mantis) nav-enemy-chase-post)
+  )
+
+;; failed to figure out what this is:
+(defstate roll-right (mantis)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior mantis) 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) 0.0)
+    (vector-normalize! (-> self root-override2 transv) -88064.0)
+    (let ((v1-6 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-6 enemy-flags)))
+          (set! (-> v1-6 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-6 enemy-flags))))
+          )
+      (set! (-> v1-6 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-6 enemy-flags))))
+      (set! (-> v1-6 nav callback-info) (-> v1-6 enemy-info-override callback-info))
+      )
+    0
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja-no-eval :group! mantis-roll-right-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-roll-right-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (let ((v1-33 self))
+      (set! (-> v1-33 enemy-flags) (the-as enemy-flag (logclear (-> v1-33 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-33 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (ja-no-eval :group! mantis-roll-right-land-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-roll-right-land-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (logior! (-> self flags) (mantis-flag attack1-enabled))
+    (go-hostile self)
+    (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 (mantis)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior mantis) 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) 27443.2)
+    (vector-xz-normalize! (-> self root-override2 transv) 102400.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.067))
+    (ja-no-eval :group! mantis-hop-left-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-hop-left-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (let ((v1-34 self))
+      (set! (-> v1-34 enemy-flags) (the-as enemy-flag (logclear (-> v1-34 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-34 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (ja-no-eval :group! mantis-hop-left-land-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-hop-left-land-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (go-hostile self)
+    (none)
+    )
+  :post (-> (method-of-type mantis roll-right) post)
+  )
+
+;; failed to figure out what this is:
+(defstate hop-away (mantis)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior mantis) enemy-event-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (enemy-method-109 self 1)
+    (logior! (-> self enemy-flags) (enemy-flag use-notice-distance))
+    (let ((v1-6 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-6 enemy-flags)))
+          (set! (-> v1-6 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-6 enemy-flags))))
+          )
+      (set! (-> v1-6 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-6 enemy-flags))))
+      (set! (-> v1-6 nav callback-info) (-> v1-6 enemy-info-override callback-info))
+      )
+    0
+    (nav-enemy-method-165 self)
+    (let ((v1-11 self))
+      (set! (-> v1-11 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-11 enemy-flags))))
+      )
+    0
+    (logclear! (-> self mask) (process-mask actor-pause))
+    (set! (-> self starting-time) (the-as uint (-> self clock frame-counter)))
+    (none)
+    )
+  :trans (behavior ()
+    '()
+    (none)
+    )
+  :code (behavior ()
+    (rlet ((acc :class vf)
+           (vf0 :class vf)
+           (vf4 :class vf)
+           (vf5 :class vf)
+           (vf6 :class vf)
+           (vf7 :class vf)
+           )
+      (init-vf0-vector)
+      (ja-channel-push! 1 (seconds 0.2))
+      (until #f
+        (let ((gp-0 (handle->process (-> self focus handle))))
+          (when gp-0
+            (let* ((v1-5 (-> self focus-pos))
+                   (s5-1 (vector-! (new 'stack-no-clear 'vector) v1-5 (-> self root-override2 trans)))
+                   )
+              (let ((s4-1 (vector-z-quaternion! (new 'stack-no-clear 'vector) (get-quat (the-as process-focusable gp-0) 0))))
+                (if (and (>= (vector-length s5-1) 122880.0) (mantis-method-194 self))
+                    (go-virtual crawl)
+                    )
+                (let ((s2-0 s5-1))
+                  (let ((s3-1 s5-1))
+                    (let ((v1-21 (* 0.2 (vector-length (get-transv (the-as process-focusable gp-0))))))
+                      (.mov vf7 v1-21)
+                      )
+                    (.lvf vf5 (&-> s4-1 quad))
+                    (.lvf vf4 (&-> s3-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 (&-> s2-0 quad) vf6)
+                  )
+                )
+              (if (not (or (mantis-method-191 self (the-as vector gp-0) s5-1) (not (mantis-method-194 self))))
+                  (go-virtual crawl)
+                  )
+              )
+            (if (and (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+                     (>= (the-as int (-> self focus aware)) 3)
+                     (enemy-method-107 self)
+                     )
+                (go-hostile self)
+                )
+            )
+          )
+        (dotimes (gp-1 (get-rand-int-range self 2 4))
+          (ja-no-eval :group! mantis-idle0-ja
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim mantis-idle0-ja) frames num-frames) -1)))
+                      :frame-num 0.0
+                      )
+          (until (ja-done? 0)
+            (suspend)
+            (ja :num! (seek!))
+            )
+          )
+        )
+      #f
+      (none)
+      )
+    )
+  :post (the-as (function none :behavior mantis) nav-enemy-face-focus-post)
+  )
+
+;; definition for method 74 of type mantis
+(defmethod enemy-method-74 mantis ((obj mantis) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (with-pp
+    (case arg2
+      (('track)
+       (if (and (-> arg3 param 0) (>= (- (-> pp clock frame-counter) (-> obj track-timer)) (seconds 0.5)))
+           'abort
+           #t
+           )
+       )
+      (('tracked)
+       (logior! (-> obj flags) (mantis-flag tracked))
+       (let ((v0-0 (the-as object (-> pp clock frame-counter))))
+         (set! (-> obj track-timer) (the-as time-frame v0-0))
+         v0-0
+         )
+       )
+      (('hit 'hit-knocked)
+       (logclear! (-> obj mask) (process-mask actor-pause))
+       (logclear! (-> obj focus-status) (focus-status dangerous))
+       (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice))
+       (logior! (-> obj enemy-flags) (enemy-flag chase-startup))
+       (logior! (-> obj focus-status) (focus-status hit))
+       (if (zero? (-> obj hit-points))
+           (logior! (-> obj focus-status) (focus-status dead))
+           )
+       (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup))
+       (enemy-method-62 obj)
+       (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
+       (process-contact-action arg0)
+       (send-event arg0 'get-attack-count 1)
+       (cond
+         ((zero? (-> obj hit-points))
+          (let ((s5-1 (-> obj incoming knocked-type)))
+            (cond
+              ((and (= s5-1 (knocked-type knocked-type-4))
+                    (not (and (-> obj next-state) (let ((v1-41 (-> obj next-state name)))
+                                                    (or (= v1-41 'knocked) (= v1-41 'jump) (= v1-41 'jump-land))
+                                                    )
+                              )
+                         )
+                    (zero? (get-rand-int obj 3))
+                    (let ((f0-0 (vector-vector-distance-squared (-> obj root-override2 trans) (target-pos 0)))
+                          (f1-0 32768.0)
+                          )
+                      (>= f0-0 (* f1-0 f1-0))
+                      )
+                    )
+               (enemy-method-73 obj)
+               )
+              ((or (= s5-1 (knocked-type knocked-type-4)) (= s5-1 (knocked-type knocked-type-6)))
+               (set! (-> obj incoming knocked-type) (knocked-type knocked-type-0))
+               (go (method-of-object obj knocked))
+               )
+              (else
+                (go (method-of-object obj knocked))
+                )
+              )
+            )
+          )
+         (else
+           (go (method-of-object obj knocked))
+           )
+         )
+       #t
+       )
+      (else
+        ((method-of-type nav-enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+        )
+      )
+    )
+  )
+
+;; definition for method 77 of type mantis
+(defmethod enemy-method-77 mantis ((obj mantis) (arg0 (pointer float)))
+  (case (-> obj incoming knocked-type)
+    (((knocked-type knocked-type-6))
+     (ja-channel-push! 1 (seconds 0.02))
+     (let ((a0-3 (-> obj skel root-channel 0)))
+       (set! (-> a0-3 frame-group) (the-as art-joint-anim (-> obj draw art-group data 27)))
+       (set! (-> a0-3 param 0)
+             (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 27)) frames num-frames) -1))
+             )
+       (set! (-> a0-3 param 1) (-> arg0 0))
+       (set! (-> a0-3 frame-num) 0.0)
+       (joint-control-channel-group! a0-3 (the-as art-joint-anim (-> obj draw art-group data 27)) num-func-seek!)
+       )
+     #t
+     )
+    (else
+      (ja-channel-push! 1 (seconds 0.2))
+      (let ((a0-5 (-> obj skel root-channel 0)))
+        (set! (-> a0-5 frame-group) (the-as art-joint-anim (-> obj draw art-group data 10)))
+        (set! (-> a0-5 param 0)
+              (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 10)) 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 (-> obj draw art-group data 10)) num-func-seek!)
+        )
+      #t
+      )
+    )
+  )
+
+;; definition for method 78 of type mantis
+(defmethod enemy-method-78 mantis ((obj mantis) (arg0 (pointer float)))
+  (cond
+    ((zero? (-> obj hit-points))
+     (ja-channel-push! 1 (seconds 0.1))
+     (let ((a0-2 (-> obj skel root-channel 0)))
+       (set! (-> a0-2 frame-group) (the-as art-joint-anim (-> obj draw art-group data 26)))
+       (set! (-> a0-2 param 0)
+             (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 26)) frames num-frames) -1))
+             )
+       (set! (-> a0-2 param 1) (-> arg0 0))
+       (set! (-> a0-2 frame-num) 0.0)
+       (joint-control-channel-group! a0-2 (the-as art-joint-anim (-> obj draw art-group data 26)) num-func-seek!)
+       )
+     #t
+     )
+    ((let ((v1-15 (-> obj incoming knocked-type)))
+       (= v1-15 (knocked-type knocked-type-6))
+       )
+     (let ((a0-4 (-> obj skel root-channel 0)))
+       (set! (-> a0-4 frame-group) (the-as art-joint-anim (-> obj draw art-group data 28)))
+       (set! (-> a0-4 param 0)
+             (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 28)) 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 (-> obj draw art-group data 28)) num-func-seek!)
+       )
+     #t
+     )
+    (else
+      (ja-channel-push! 1 (seconds 0.1))
+      (let ((a0-6 (-> obj skel root-channel 0)))
+        (set! (-> a0-6 frame-group) (the-as art-joint-anim (-> obj draw art-group data 11)))
+        (set! (-> a0-6 param 0)
+              (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 11)) frames num-frames) -1))
+              )
+        (set! (-> a0-6 param 1) (-> arg0 0))
+        (set! (-> a0-6 frame-num) 0.0)
+        (joint-control-channel-group! a0-6 (the-as art-joint-anim (-> obj draw art-group data 11)) num-func-seek!)
+        )
+      #t
+      )
+    )
+  )
+
+;; definition for method 125 of type mantis
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch symbol vs pat-surface.
+(defmethod enemy-method-125 mantis ((obj mantis) (arg0 collide-query) (arg1 collide-spec) (arg2 float) (arg3 float) (arg4 float))
+  (with-pp
+    (the-as
+      pat-surface
+      (when (find-ground (-> obj root-override2) arg0 arg1 arg2 arg3 arg4)
+        (set! (-> obj root-override2 ground-pat) (-> arg0 best-other-tri pat))
+        (when (>= (- (-> pp clock frame-counter) (-> obj gspot-timer)) (seconds 0.2))
+          (let ((a1-2 (new 'stack-no-clear 'collide-query)))
+            (set! (-> a1-2 start-pos quad) (-> obj root-override2 gspot-pos quad))
+            (set! (-> a1-2 start-pos y) (+ 2048.0 (-> a1-2 start-pos y)))
+            (set-vector! (-> a1-2 move-dist) 0.0 -6144.0 0.0 0.0)
+            (let ((v1-10 a1-2))
+              (set! (-> v1-10 radius) 4915.2)
+              (set! (-> v1-10 collide-with) arg1)
+              (set! (-> v1-10 ignore-process0) obj)
+              (set! (-> v1-10 ignore-process1) #f)
+              (set! (-> v1-10 ignore-pat) (-> obj root-override2 pat-ignore-mask))
+              (set! (-> v1-10 action-mask) (collide-action solid))
+              )
+            (fill-using-line-sphere *collide-cache* a1-2)
+            )
+          (let ((s5-1 (new 'stack-no-clear 'vector)))
+            (vector-reset! s5-1)
+            (dotimes (s4-1 (-> *collide-cache* num-tris))
+              (let* ((v1-16 (-> *collide-cache* tris s4-1))
+                     (s2-1 (vector-! (new 'stack-no-clear 'vector) (-> v1-16 vertex 1) (the-as vector (-> v1-16 vertex))))
+                     (s1-1 (vector-! (new 'stack-no-clear 'vector) (-> v1-16 vertex 2) (the-as vector (-> v1-16 vertex))))
+                     (s3-0 (new 'stack-no-clear 'vector))
+                     )
+                (vector-normalize! s2-1 1.0)
+                (vector-normalize! s1-1 1.0)
+                (vector-cross! s3-0 s2-1 s1-1)
+                (if (< (cos 10922.667) (vector-dot s3-0 *y-vector*))
+                    (vector+! s5-1 s5-1 s3-0)
+                    )
+                )
+              )
+            (vector-normalize-copy! (-> obj gspot-normal) s5-1 1.0)
+            )
+          (set! (-> obj gspot-timer) (-> pp clock frame-counter))
+          )
+        #t
+        )
+      )
+    )
+  )
+
+;; definition for method 194 of type mantis
+;; WARN: Return type mismatch object vs symbol.
+(defmethod mantis-method-194 mantis ((obj mantis))
+  (let ((a0-2 (nav-mesh-from-res-tag (-> obj entity) 'nav-mesh-actor 1))
+        (gp-0 (new 'stack-no-clear 'vector))
+        )
+    (the-as symbol (and a0-2
+                        (nav-mesh-method-10 a0-2 gp-0 (-> obj root-override2 trans) (the-as nav-poly #f))
+                        (< (vector-vector-xz-distance gp-0 (-> obj root-override2 trans)) 2048.0)
+                        )
+            )
+    )
+  )
+
+;; definition for method 193 of type mantis
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod mantis-method-193 mantis ((obj mantis) (arg0 vector))
+  (with-pp
+    (cond
+      ((= (-> obj root-override2 gspot-pos y) -40959590.0)
+       (set! (-> arg0 y) 0.0)
+       (vector-normalize! arg0 1.0)
+       (quaternion-set! (-> obj root-override2 quat) 0.0 (-> arg0 x) 0.0 (+ 1.0 (-> arg0 z)))
+       (quaternion-normalize! (-> obj root-override2 quat))
+       )
+      (else
+        (let ((s4-0 (new 'stack-no-clear 'vector)))
+          (set! (-> s4-0 quad) (-> *up-vector* quad))
+          (let ((s3-0 (new 'stack-no-clear 'quaternion)))
+            (quaternion-from-two-vectors-max-angle! s3-0 s4-0 (-> obj gspot-normal) 10922.667)
+            (vector-orient-by-quat! s4-0 s4-0 s3-0)
+            )
+          (let ((s3-1 (-> obj my-up-vector)))
+            (vector-deg-seek s3-1 s3-1 s4-0 (* 8192.0 (-> pp clock seconds-per-frame)))
+            (vector-normalize! s3-1 1.0)
+            (set! (-> arg0 y) 0.0)
+            (vector-normalize! arg0 1.0)
+            (forward-up-nopitch->quaternion (-> obj root-override2 quat) arg0 s3-1)
+            )
+          )
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+;; definition for method 142 of type mantis
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod nav-enemy-method-142 mantis ((obj mantis) (arg0 nav-control))
+  (let ((t9-0 (method-of-object obj mantis-method-193))
+        (a2-0 (-> arg0 state))
+        (a1-1 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> a1-1 quad) (-> a2-0 heading quad))
+    (t9-0 obj a1-1)
+    )
+  0
+  (none)
+  )
+
+;; definition for method 55 of type mantis
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch vector vs none.
+(defmethod enemy-method-55 mantis ((obj mantis))
+  (local-vars (s5-0 vector))
+  (let ((t9-0 (method-of-type nav-enemy enemy-method-55)))
+    (t9-0 obj)
+    )
+  (logclear! (-> obj flags) (mantis-flag tracked))
+  (let ((a0-4 (handle->process (-> obj focus handle))))
+    (set! s5-0 (when a0-4
+                 (set! s5-0 (-> obj focus-pos))
+                 (set! (-> s5-0 quad) (-> (get-trans (the-as process-focusable a0-4) 0) quad))
+                 s5-0
+                 )
+          )
+    )
+  (none)
+  )
+
+;; definition for method 187 of type mantis
+;; WARN: Return type mismatch object vs none.
+(defmethod mantis-method-187 mantis ((obj mantis))
+  (let ((s3-0 (vector-x-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
+        (s4-0 (-> obj root-override2))
+        (s5-0 (lambda ((arg0 mantis) (arg1 collide-shape-moving) (arg2 vector))
+                (let ((s3-0 (new 'stack-no-clear 'vector))
+                      (f30-0 (vector-length arg2))
+                      )
+                  (clamp-vector-to-mesh-cross-gaps
+                    (-> arg0 nav)
+                    (-> arg1 trans)
+                    (-> arg0 nav state current-poly)
+                    arg2
+                    204.8
+                    #f
+                    (the-as clamp-travel-vector-to-mesh-return-info #f)
+                    )
+                  (vector+! s3-0 (-> arg1 trans) arg2)
+                  (cond
+                    ((< (vector-vector-xz-distance (-> arg1 trans) s3-0) (+ -8192.0 f30-0))
+                     #f
+                     )
+                    ((let ((a1-5 (new 'stack-no-clear 'vector)))
+                       (set! (-> a1-5 quad) (-> s3-0 quad))
+                       (set! (-> a1-5 w) (-> arg0 root-override2 nav-radius))
+                       (add-root-sphere-to-hash! (-> arg0 nav) a1-5 1134)
+                       )
+                     #f
+                     )
+                    (else
+                      (let ((a1-6 (new 'stack-no-clear 'collide-query)))
+                        (set! (-> a1-6 start-pos quad) (-> arg1 trans quad))
+                        (set! (-> a1-6 move-dist quad) (-> arg2 quad))
+                        (let ((v1-14 a1-6))
+                          (set! (-> v1-14 radius) 2048.0)
+                          (set! (-> v1-14 collide-with) (-> arg1 root-prim prim-core collide-with))
+                          (set! (-> v1-14 ignore-process0) arg0)
+                          (set! (-> v1-14 ignore-process1) #f)
+                          (set! (-> v1-14 ignore-pat) (-> arg1 pat-ignore-mask))
+                          (set! (-> v1-14 action-mask) (collide-action solid))
+                          )
+                        (if (>= (fill-and-probe-using-line-sphere *collide-cache* a1-6) 0.0)
+                            #f
+                            #t
+                            )
+                        )
+                      )
+                    )
+                  )
+                )
+              )
+        )
+    (cond
+      ((s5-0 obj s4-0 (vector-normalize-copy! (new 'stack-no-clear 'vector) s3-0 -40960.0))
+       (go (method-of-object obj roll-right))
+       )
+      ((s5-0 obj s4-0 (vector-normalize-copy! (new 'stack-no-clear 'vector) s3-0 34160.64))
+       (go (method-of-object obj roll-left))
+       )
+      )
+    )
+  (none)
+  )
+
+;; definition for method 188 of type mantis
+;; WARN: Return type mismatch int vs none.
+(defmethod mantis-method-188 mantis ((obj mantis))
+  (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
+        (let* ((v1-4 (-> obj focus-pos))
+               (s4-1 (vector-! (new 'stack-no-clear 'vector) v1-4 (-> obj root-override2 trans)))
+               )
+          (let ((s2-1 (vector-z-quaternion! (new 'stack-no-clear 'vector) (get-quat (the-as process-focusable s5-0) 0)))
+                (s1-0 s4-1)
+                )
+            (let ((s3-1 s4-1))
+              (let ((v1-10 (* 0.2 (vector-length (get-transv (the-as process-focusable s5-0))))))
+                (.mov vf7 v1-10)
+                )
+              (.lvf vf5 (&-> s2-1 quad))
+              (.lvf vf4 (&-> s3-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 (&-> s1-0 quad) vf6)
+            )
+          (mantis-method-191 obj (the-as vector s5-0) s4-1)
+          )
+        )
+      )
+    (none)
+    )
+  )
+
+;; definition for method 67 of type mantis
+;; WARN: Return type mismatch object vs none.
+(defmethod go-stare mantis ((obj mantis))
+  (let ((a0-2 (handle->process (-> obj focus handle))))
+    (if (and a0-2
+             (and (< 81920.0
+                     (vector-vector-xz-distance (-> obj root-override2 trans) (get-trans (the-as process-focusable a0-2) 0))
+                     )
+                  (mantis-method-194 obj)
+                  )
+             )
+        (go (method-of-object obj crawl))
+        )
+    )
+  (go (method-of-object obj hop-away))
+  (none)
+  )
+
+;; definition for method 190 of type mantis
+;; WARN: Return type mismatch int vs none.
+(defmethod mantis-method-190 mantis ((obj mantis) (arg0 vector) (arg1 vector))
+  (let ((s5-0 (-> obj jump)))
+    (let* ((f0-0 (vector-length arg1))
+           (f0-1 (if (< 102400.0 f0-0)
+                     81920.0
+                     (+ -20480.0 f0-0)
+                     )
+                 )
+           )
+      (vector-normalize! arg1 f0-1)
+      )
+    (when (mantis-method-189 obj (-> s5-0 destination) arg1)
+      (set! (-> s5-0 direction) (the-as uint 0))
+      (set! (-> s5-0 start-anim) (the-as uint 12))
+      (set! (-> s5-0 air-anim) (the-as uint 13))
+      (set! (-> s5-0 land-anim) (the-as uint 0))
+      (set! (-> obj enemy-flags) (the-as enemy-flag (logclear (-> obj enemy-flags) (enemy-flag vulnerable))))
+      (send-event obj 'jump 0 (-> s5-0 destination))
+      )
+    )
+  0
+  (none)
+  )
+
+;; definition for method 191 of type mantis
+(defmethod mantis-method-191 mantis ((obj mantis) (arg0 vector) (arg1 vector))
+  (let ((s5-0 (-> obj jump)))
+    (vector-length arg1)
+    (vector-normalize! arg1 1.0)
+    (vector-rotate-y! arg1 arg1 (* 182.04445 (get-rand-float-range obj -45.0 45.0)))
+    (let ((a2-5
+            (vector-normalize-copy! (new 'stack-no-clear 'vector) arg1 (* 4096.0 (get-rand-float-range obj -4.0 -6.0)))
+            )
+          )
+      (when (mantis-method-189 obj (-> s5-0 destination) a2-5)
+        (set! (-> s5-0 direction) (the-as uint 1))
+        (set! (-> s5-0 start-anim) (the-as uint 14))
+        (set! (-> s5-0 air-anim) (the-as uint 15))
+        (set! (-> s5-0 land-anim) (the-as uint 16))
+        (set! (-> obj enemy-flags) (the-as enemy-flag (logclear (-> obj enemy-flags) (enemy-flag vulnerable))))
+        (send-event obj 'jump 0 (-> s5-0 destination))
+        )
+      )
+    )
+  0
+  )
+
+;; definition for method 192 of type mantis
+;; WARN: Return type mismatch int vs none.
+(defmethod mantis-method-192 mantis ((obj mantis) (arg0 vector) (arg1 vector))
+  (let ((s5-0 (-> obj jump)))
+    (vector-length arg1)
+    (vector-normalize! arg1 1.0)
+    (vector-rotate-y! arg1 arg1 (* 182.04445 (get-rand-float-range obj -45.0 45.0)))
+    (let ((a2-5
+            (vector-normalize-copy! (new 'stack-no-clear 'vector) arg1 (* 4096.0 (get-rand-float-range obj -15.0 -22.0)))
+            )
+          )
+      (when (mantis-method-189 obj (-> s5-0 destination) a2-5)
+        (set! (-> s5-0 direction) (the-as uint 1))
+        (set! (-> s5-0 start-anim) (the-as uint 20))
+        (set! (-> s5-0 air-anim) (the-as uint 21))
+        (set! (-> s5-0 land-anim) (the-as uint 22))
+        (set! (-> obj enemy-flags) (the-as enemy-flag (logclear (-> obj enemy-flags) (enemy-flag vulnerable))))
+        (send-event obj 'jump 0 (-> s5-0 destination))
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+;; definition for method 189 of type mantis
+(defmethod mantis-method-189 mantis ((obj mantis) (arg0 vector) (arg1 vector))
+  (let* ((s4-0 (vector-normalize-copy! (new 'stack-no-clear 'vector) arg1 1.0))
+         (f30-0 (vector-length arg1))
+         (f28-0 3640.889)
+         (f26-0 f28-0)
+         (s3-1
+           (lambda ((arg0 mantis) (arg1 vector) (arg2 float) (arg3 float) (arg4 vector))
+             (local-vars (v0-3 vector))
+             (let* ((s3-0 (-> arg0 root-override2 trans))
+                    (a0-2 (vector-rotate-y! (new 'stack-no-clear 'vector) arg1 arg3))
+                    (s5-1 (vector+float*! (new 'stack-no-clear 'vector) s3-0 a0-2 arg2))
+                    (s2-0 (new 'stack-no-clear 'vector))
+                    )
+               (cloest-point-on-mesh (-> arg0 nav) s5-1 s5-1 (the-as nav-poly #f))
+               (vector-! s2-0 s5-1 s3-0)
+               (clamp-vector-to-mesh-cross-gaps
+                 (-> arg0 nav)
+                 s3-0
+                 (-> arg0 nav state current-poly)
+                 s2-0
+                 204.8
+                 #f
+                 (the-as clamp-travel-vector-to-mesh-return-info #f)
+                 )
+               (when (< 0.8 (/ (vector-length s2-0) arg2))
+                 (vector+! s5-1 s3-0 s2-0)
+                 (let ((a1-7 (new 'stack-no-clear 'collide-query)))
+                   (set! (-> a1-7 start-pos quad) (-> s3-0 quad))
+                   (set! (-> a1-7 move-dist quad) (-> s2-0 quad))
+                   (+! (-> a1-7 start-pos y) (* 1.5 (-> arg0 enemy-info-override jump-height-min)))
+                   (let ((v1-17 a1-7))
+                     (set! (-> v1-17 radius) 409.6)
+                     (set! (-> v1-17 collide-with) (collide-spec backgnd))
+                     (set! (-> v1-17 ignore-process0) #f)
+                     (set! (-> v1-17 ignore-process1) #f)
+                     (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))
+                     )
+                   (when (< (fill-and-probe-using-line-sphere *collide-cache* a1-7) 0.0)
+                     (set! (-> s5-1 w) (-> arg0 root-override2 nav-radius))
+                     (when (not (add-root-sphere-to-hash! (-> arg0 nav) s5-1 #x8046e))
+                       (set! (-> arg4 quad) (-> s5-1 quad))
+                       (return arg4)
+                       v0-3
+                       )
+                     )
+                   )
+                 )
+               )
+             )
+           )
+         )
+    (cond
+      ((s3-1 obj s4-0 f30-0 0.0 arg0)
+       #t
+       )
+      (else
+        (dotimes (s2-0 2)
+          (if (or (s3-1 obj s4-0 f30-0 f26-0 arg0) (s3-1 obj s4-0 f30-0 (- f26-0) arg0))
+              (return #t)
+              )
+          (+! f26-0 f28-0)
+          )
+        #f
+        )
+      )
+    )
+  )
+
+;; definition for method 89 of type mantis
+(defmethod enemy-method-89 mantis ((obj mantis) (arg0 enemy-jump-info))
+  (ja-channel-push! 1 (seconds 0.1))
+  (let ((a1-2 (-> obj draw art-group data (-> obj jump start-anim)))
+        (a0-4 (-> obj skel root-channel 0))
+        )
+    (set! (-> a0-4 frame-group) (the-as art-joint-anim a1-2))
+    (set! (-> a0-4 param 0) (the float (+ (-> (the-as art-joint-anim a1-2) frames num-frames) -1)))
+    (set! (-> a0-4 param 1) (-> arg0 anim-speed))
+    (set! (-> a0-4 frame-num) 0.0)
+    (joint-control-channel-group! a0-4 (the-as art-joint-anim a1-2) num-func-seek!)
+    )
+  #t
+  )
+
+;; definition for method 87 of type mantis
+(defmethod enemy-method-87 mantis ((obj mantis) (arg0 enemy-jump-info))
+  (ja-channel-push! 1 (seconds 0.1))
+  (let ((a1-2 (-> obj draw art-group data (-> obj jump air-anim)))
+        (a0-4 (-> obj skel root-channel 0))
+        )
+    (set! (-> a0-4 frame-group) (the-as art-joint-anim a1-2))
+    (set! (-> a0-4 param 0) (the float (+ (-> (the-as art-joint-anim a1-2) frames num-frames) -1)))
+    (set! (-> a0-4 param 1) (-> arg0 anim-speed))
+    (set! (-> a0-4 frame-num) 0.0)
+    (joint-control-channel-group! a0-4 (the-as art-joint-anim a1-2) num-func-seek!)
+    )
+  #t
+  )
+
+;; definition for method 92 of type mantis
+;; WARN: Return type mismatch quaternion vs none.
+(defmethod enemy-method-92 mantis ((obj mantis) (arg0 int) (arg1 nav-poly))
+  "TODO - nav-poly is a guess
+@abstract"
+  (let ((v1-0 arg0))
+    (when (or (zero? v1-0) (= v1-0 1) (= v1-0 2) (= v1-0 3))
+      (let ((a0-4 obj))
+        (when (logtest? (enemy-flag enemy-flag37) (-> a0-4 enemy-flags))
+          (let ((s5-1 (vector-! (new 'stack-no-clear 'vector) (-> arg1 vertex2) (-> obj root-override2 trans))))
+            (vector-normalize! s5-1 1.0)
+            (let ((v1-5 (-> obj jump direction)))
+              (cond
+                ((zero? v1-5)
+                 )
+                ((= v1-5 1)
+                 (vector-negate! s5-1 s5-1)
+                 )
+                ((= v1-5 2)
+                 (vector-rotate-y! s5-1 s5-1 -16384.0)
+                 )
+                ((= v1-5 3)
+                 (vector-rotate-y! s5-1 s5-1 16384.0)
+                 )
+                )
+              )
+            (seek-toward-heading-vec! (-> obj root-override2) s5-1 (-> obj nav max-rotation-rate) (seconds 0.02))
+            )
+          )
+        )
+      )
+    )
+  (none)
+  )
+
+;; definition for method 88 of type mantis
+(defmethod enemy-method-88 mantis ((obj mantis) (arg0 enemy-jump-info))
+  (cond
+    ((zero? (-> obj jump land-anim))
+     #f
+     )
+    (else
+      (ja-channel-push! 1 (seconds 0.075))
+      (let ((a1-2 (-> obj draw art-group data (-> obj jump land-anim)))
+            (a0-4 (-> obj skel root-channel 0))
+            )
+        (set! (-> a0-4 frame-group) (the-as art-joint-anim a1-2))
+        (set! (-> a0-4 param 0) (the float (+ (-> (the-as art-joint-anim a1-2) frames num-frames) -1)))
+        (set! (-> a0-4 param 1) (-> arg0 anim-speed))
+        (set! (-> a0-4 frame-num) 0.0)
+        (joint-control-channel-group! a0-4 (the-as art-joint-anim a1-2) num-func-seek!)
+        )
+      #t
+      )
+    )
+  )
+
+;; definition for method 60 of type mantis
+(defmethod coin-flip? mantis ((obj mantis))
+  "@returns The result of a 50/50 RNG roll"
+  #f
+  )
+
+;; definition for method 114 of type mantis
+;; WARN: Return type mismatch collide-shape-moving vs none.
+(defmethod enemy-method-114 mantis ((obj mantis))
+  "@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 8) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 9))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec enemy))
+      (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 can-ride deadly no-standon))
+      (set-vector! (-> s4-0 local-sphere) 0.0 6144.0 0.0 17408.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 crate obstacle hit-by-others-list player-list)
+            )
+      (set! (-> v1-13 prim-core action) (collide-action solid can-ride deadly no-standon))
+      (set-vector! (-> v1-13 local-sphere) 0.0 4915.2 0.0 4915.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 enemy))
+      (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) 7)
+      (set-vector! (-> v1-15 local-sphere) 0.0 0.0 0.0 2048.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 player-list))
+      (set! (-> v1-17 prim-core action) (collide-action solid))
+      (set! (-> v1-17 transform-index) 13)
+      (set-vector! (-> v1-17 local-sphere) 0.0 0.0 0.0 2048.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 player-list))
+      (set! (-> v1-19 prim-core action) (collide-action solid))
+      (set! (-> v1-19 transform-index) 10)
+      (set-vector! (-> v1-19 local-sphere) 0.0 0.0 0.0 2048.0)
+      )
+    (let ((v1-21 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-21 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-21 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-21 prim-core action) (collide-action solid deadly))
+      (set! (-> v1-21 transform-index) 24)
+      (set-vector! (-> v1-21 local-sphere) 0.0 0.0 0.0 2457.6)
+      )
+    (let ((v1-23 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-23 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-23 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-23 prim-core action) (collide-action solid deadly))
+      (set! (-> v1-23 transform-index) 19)
+      (set-vector! (-> v1-23 local-sphere) 0.0 0.0 0.0 2457.6)
+      )
+    (let ((v1-25 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-25 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-25 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-25 prim-core action) (collide-action solid deadly))
+      (set! (-> v1-25 transform-index) 27)
+      (set-vector! (-> v1-25 local-sphere) 0.0 0.0 0.0 1228.8)
+      )
+    (let ((v1-27 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-27 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-27 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-27 prim-core action) (collide-action solid deadly))
+      (set! (-> v1-27 transform-index) 28)
+      (set-vector! (-> v1-27 local-sphere) 0.0 0.0 0.0 2048.0)
+      )
+    (set! (-> s5-0 nav-radius) 8192.0)
+    (let ((v1-29 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-29 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-29 prim-core collide-with))
+      )
+    (set! (-> obj root-override2) s5-0)
+    )
+  (none)
+  )
+
+;; definition for method 115 of type mantis
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-115 mantis ((obj mantis))
+  "@abstract"
+  (with-pp
+    (initialize-skeleton
+      obj
+      (the-as skeleton-group (art-group-get-by-name *level* "skel-mantis" (the-as (pointer uint32) #f)))
+      (the-as pair 0)
+      )
+    (enemy-method-113 obj *mantis-nav-enemy-info*)
+    (set! (-> obj flags) (mantis-flag))
+    (set! (-> obj my-up-vector quad) (-> *y-vector* quad))
+    (set! (-> obj gspot-normal quad) (-> *y-vector* quad))
+    (set! (-> obj gspot-timer) 0)
+    (set! (-> obj attack-timer) (+ (-> pp clock frame-counter) (seconds -5)))
+    (set! (-> obj track-timer) 0)
+    (set! (-> obj draw light-index) (the-as uint 30))
+    (none)
+    )
+  )
diff --git a/test/decompiler/reference/jak2/levels/nest/nest-obs_REF.gc b/test/decompiler/reference/jak2/levels/nest/nest-obs_REF.gc
new file mode 100644
index 0000000000..2f5dbfb043
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/nest/nest-obs_REF.gc
@@ -0,0 +1,309 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type nest-switch
+(deftype nest-switch (process-drawable)
+  ((set-camera   symbol        :offset-assert 200)
+   (notify-actor entity-actor  :offset-assert 204)
+   (y-start      float         :offset-assert 208)
+   (y-delta      float         :offset-assert 212)
+   (y-rot-rate   float         :offset-assert 216)
+   )
+  :heap-base #x60
+  :method-count-assert 22
+  :size-assert         #xdc
+  :flag-assert         #x16006000dc
+  (:methods
+    (up () _type_ :state 20)
+    (down () _type_ :state 21)
+    )
+  )
+
+;; definition for method 3 of type nest-switch
+(defmethod inspect nest-switch ((obj nest-switch))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tset-camera: ~A~%" (-> obj set-camera))
+  (format #t "~2Tnotify-actor: ~A~%" (-> obj notify-actor))
+  (format #t "~2Ty-start: ~f~%" (-> obj y-start))
+  (format #t "~2Ty-delta: ~f~%" (-> obj y-delta))
+  (format #t "~2Ty-rot-rate: ~f~%" (-> obj y-rot-rate))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-nest-switch cas-switch 0 2
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 2 0 3.5)
+              :origin-joint-index 3
+              )
+
+;; failed to figure out what this is:
+(defstate up (nest-switch)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('attack)
+       (let ((v1-1 (the-as attack-info (-> event param 1))))
+         (when (or (= (-> v1-1 mode) 'spin) (= (-> v1-1 mode) 'spin-air))
+           (let ((a1-3 (new 'stack-no-clear 'event-message-block)))
+             (set! (-> a1-3 from) (process->ppointer self))
+             (set! (-> a1-3 num-params) 0)
+             (set! (-> a1-3 message) 'trigger)
+             (let ((t9-0 send-event-function)
+                   (v1-6 (-> self notify-actor))
+                   )
+               (t9-0
+                 (if v1-6
+                     (-> v1-6 extra process)
+                     )
+                 a1-3
+                 )
+               )
+             )
+           (go-virtual down)
+           )
+         )
+       )
+      )
+    )
+  :trans (the-as (function none :behavior nest-switch) rider-trans)
+  :code (the-as (function none :behavior nest-switch) sleep-code)
+  :post (the-as (function none :behavior nest-switch) rider-post)
+  )
+
+;; failed to figure out what this is:
+(defstate down (nest-switch)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self set-camera) #f)
+    (none)
+    )
+  :trans (behavior ()
+    (when (and (not (-> self set-camera)) (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.6)))
+      (process-grab? *target* #f)
+      (hide-hud-quick #f)
+      (set-setting! 'process-mask 'set 0 (process-mask movie enemy))
+      (set-setting! 'entity-name "camera-253" 0 0)
+      (set! (-> self set-camera) #t)
+      )
+    (rider-trans)
+    (none)
+    )
+  :code (behavior ()
+    (set! (-> self y-rot-rate) 0.0)
+    (logclear! (-> self mask) (process-mask actor-pause))
+    (while (< 0.0 (-> self y-delta))
+      (seek! (-> self y-rot-rate) 500.0 (* 1000.0 (-> self clock seconds-per-frame)))
+      (quaternion-rotate-y!
+        (-> self root quat)
+        (-> self root quat)
+        (* 182.04445 (-> self clock seconds-per-frame) (-> self y-rot-rate))
+        )
+      (seek! (-> self y-delta) 0.0 (* 4096.0 (-> self clock seconds-per-frame) (* 0.006 (-> self y-rot-rate))))
+      (set! (-> self root trans y) (+ (-> self y-start) (-> self y-delta)))
+      (suspend)
+      )
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 1))
+        (seek! (-> self y-rot-rate) 0.0 (* 4000.0 (-> self clock seconds-per-frame)))
+        (quaternion-rotate-y!
+          (-> self root quat)
+          (-> self root quat)
+          (* 182.04445 (-> self clock seconds-per-frame) (-> self y-rot-rate))
+          )
+        (suspend)
+        )
+      )
+    (let ((gp-1 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-1) (seconds 1))
+        (suspend)
+        )
+      )
+    (remove-setting! 'entity-name)
+    (remove-setting! 'process-mask)
+    (process-release? *target*)
+    (logior! (-> self mask) (process-mask actor-pause))
+    (sleep-code)
+    (none)
+    )
+  :post (the-as (function none :behavior nest-switch) rider-post)
+  )
+
+;; definition for method 11 of type nest-switch
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! nest-switch ((obj nest-switch) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (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))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak hit-by-others-list player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid no-standon))
+      (set-vector! (-> s3-0 local-sphere) 0.0 4096.0 0.0 20480.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (let ((v1-8 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-8 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-8 prim-core collide-with) (collide-spec jak hit-by-others-list 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 8192.0 0.0 14336.0)
+      )
+    (let ((v1-10 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 1))))
+      (set! (-> v1-10 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-10 prim-core collide-with) (collide-spec jak hit-by-others-list player-list))
+      (set! (-> v1-10 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-10 transform-index) 3)
+      (set-vector! (-> v1-10 local-sphere) 0.0 8192.0 0.0 14336.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 obstacle))
+      (set! (-> v1-12 prim-core action) (collide-action solid no-standon))
+      (set! (-> v1-12 transform-index) 3)
+      (set-vector! (-> v1-12 local-sphere) 0.0 8192.0 0.0 8192.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-nest-switch" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj notify-actor) (entity-actor-lookup arg0 'alt-actor 0))
+  (set! (-> obj y-start) (+ -12288.0 (-> obj root trans y)))
+  (set! (-> obj y-delta) 12288.0)
+  (go (method-of-object obj up))
+  (none)
+  )
+
+;; definition of type nest-piston
+(deftype nest-piston (process-drawable)
+  ((y-level  float  :offset-assert 200)
+   (y-offset float  :offset-assert 204)
+   )
+  :heap-base #x50
+  :method-count-assert 22
+  :size-assert         #xd0
+  :flag-assert         #x16005000d0
+  (:methods
+    (idle () _type_ :state 20)
+    (up () _type_ :state 21)
+    )
+  )
+
+;; definition for method 3 of type nest-piston
+(defmethod inspect nest-piston ((obj nest-piston))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Ty-level: ~f~%" (-> obj y-level))
+  (format #t "~2Ty-offset: ~f~%" (-> obj y-offset))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-nest-piston piston piston-lod0-jg piston-idle-ja
+              ((piston-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+;; failed to figure out what this is:
+(defstate idle (nest-piston)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('trigger)
+       (go-virtual up)
+       )
+      )
+    )
+  :code (the-as (function none :behavior nest-piston) sleep-code)
+  )
+
+;; failed to figure out what this is:
+(defstate up (nest-piston)
+  :virtual #t
+  :trans (the-as (function none :behavior nest-piston) rider-trans)
+  :code (behavior ()
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 1))
+        (suspend)
+        )
+      )
+    (while (< (-> self y-offset) 16384.0)
+      (seek! (-> self y-offset) 16384.0 (* 8192.0 (-> self clock seconds-per-frame)))
+      (set! (-> self root trans y) (+ (-> self y-level) (-> self y-offset)))
+      (suspend)
+      )
+    (logior! (-> self mask) (process-mask actor-pause))
+    (sleep-code)
+    (none)
+    )
+  :post (the-as (function none :behavior nest-piston) rider-post)
+  )
+
+;; definition for method 11 of type nest-piston
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! nest-piston ((obj nest-piston) (arg0 entity-actor))
+  "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
+This commonly includes things such as:
+- stack size
+- collision information
+- loading the skeleton group / bones
+- sounds"
+  (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 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 29081.6 0.0 31948.8)
+      (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-nest-piston" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (set! (-> obj root trans y) (+ 8192.0 (-> obj root trans y)))
+  (set! (-> obj y-level) (-> obj root trans y))
+  (set! (-> obj y-offset) 0.0)
+  (transform-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/undefined/hal-h_REF.gc b/test/decompiler/reference/jak2/levels/undefined/hal-h_REF.gc
index e205c434ee..fb5c883f0e 100644
--- a/test/decompiler/reference/jak2/levels/undefined/hal-h_REF.gc
+++ b/test/decompiler/reference/jak2/levels/undefined/hal-h_REF.gc
@@ -4,15 +4,15 @@
 ;; definition of type hal
 (deftype hal (bot)
   ((handle-failed-slave-id int8     :offset-assert 992)
-   (slave-handle           uint64 3 :offset-assert 1000)
+   (slave-handle           handle 3 :offset-assert 1000)
    )
   :heap-base #x380
   :method-count-assert 227
   :size-assert         #x400
   :flag-assert         #xe303800400
   (:methods
-    (hal-method-225 () none 225)
-    (hal-method-226 () none 226)
+    (hal-method-225 (_type_) symbol 225)
+    (hal-method-226 (_type_) symbol 226)
     )
   )
 
@@ -33,10 +33,10 @@
 
 ;; definition of type halt-wait-spot
 (deftype halt-wait-spot (ai-task)
-  ((check-done   basic   :offset  32)
-   (which-spot   int8    :offset  36)
-   (num-spots    uint8   :offset  37)
-   (spot-indexes int8  6 :offset  38)
+  ((check-done   (function halt-wait-spot hal symbol)   :offset  32)
+   (which-spot   int8                                   :offset  36)
+   (num-spots    uint8                                  :offset  37)
+   (spot-indexes uint8                                6 :offset  38)
    )
   :method-count-assert 12
   :size-assert         #x30
@@ -65,7 +65,3 @@
 
 ;; failed to figure out what this is:
 0
-
-
-
-
diff --git a/test/decompiler/reference/jak2/levels/undefined/hal-task_REF.gc b/test/decompiler/reference/jak2/levels/undefined/hal-task_REF.gc
new file mode 100644
index 0000000000..3131cea33e
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/undefined/hal-task_REF.gc
@@ -0,0 +1,41 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for method 9 of type halt-wait-spot
+;; WARN: Return type mismatch int vs none.
+(defmethod reset-task! halt-wait-spot ((obj halt-wait-spot))
+  "Virtual"
+  (set! (-> obj check-done) #f)
+  (set! (-> obj which-spot) 0)
+  (set! (-> obj num-spots) (the-as uint 1))
+  (none)
+  )
+
+;; definition for method 11 of type halt-wait-spot
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch symbol vs none.
+(defmethod ai-task-method-11 halt-wait-spot ((obj halt-wait-spot) (arg0 bot))
+  "Virtual"
+  (let ((s4-0 (-> obj which-spot)))
+    (if (logtest? *display-bot-marks* (bot-marks-controls bmc16))
+        (bot-debug-draw-spot-sphere
+          arg0
+          (the-as int (-> obj num-spots))
+          (the-as (pointer uint) (-> obj spot-indexes))
+          (the-as int (-> obj spot-indexes s4-0))
+          )
+        )
+    (mem-copy!
+      (the-as pointer (-> arg0 spot))
+      (the-as pointer (-> arg0 course spots (-> obj spot-indexes s4-0)))
+      20
+      )
+    )
+  (set! (-> arg0 root-override2 trans quad) (-> arg0 spot center quad))
+  ((-> obj check-done) obj (the-as hal arg0))
+  (none)
+  )
+
+
+
+
diff --git a/test/offline/config/jak2/config.jsonc b/test/offline/config/jak2/config.jsonc
index 78ba41b7b9..fd2208b390 100644
--- a/test/offline/config/jak2/config.jsonc
+++ b/test/offline/config/jak2/config.jsonc
@@ -21,6 +21,7 @@
     "DGO/CTA.DGO",
     "DGO/CTB.DGO",
     "DGO/CTC.DGO",
+    "DGO/CTYKORA.DGO",
     "DGO/CWI.DGO",
     "DGO/DG1.DGO",
     "DGO/DMI.DGO",