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

;; definition of type level-vis-info
(deftype level-vis-info (basic)
  ((level              level                  :offset-assert   4)
   (from-level         level                  :offset-assert   8)
   (from-bsp           bsp-header             :offset-assert  12)
   (flags              vis-info-flag          :offset-assert  16)
   (length             uint32                 :offset-assert  20)
   (allocated-length   uint32                 :offset-assert  24)
   (dictionary-length  uint32                 :offset-assert  28)
   (dictionary         uint32                 :offset-assert  32)
   (string-block       uint32                 :offset-assert  36)
   (ramdisk            uint32                 :offset-assert  40)
   (vis-bits           uint32                 :offset-assert  44)
   (current-vis-string uint32                 :offset-assert  48)
   (vis-string         uint32        :dynamic :offset-assert  52)
   )
  :method-count-assert 9
  :size-assert         #x34
  :flag-assert         #x900000034
  )

;; definition for method 3 of type level-vis-info
(defmethod inspect level-vis-info ((obj level-vis-info))
  (when (not obj)
    (set! obj obj)
    (goto cfg-68)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Tlevel: ~A~%" (-> obj level))
  (format #t "~1Tfrom-level: ~A~%" (-> obj from-level))
  (format #t "~1Tfrom-bsp: ~A~%" (-> obj from-bsp))
  (format #t "~1Tflags: #x~X : (vis-info-flag " (-> obj flags))
  (let ((s5-0 (-> obj flags)))
    (if (= (logand (vis-info-flag dummy22) s5-0) (vis-info-flag dummy22))
        (format #t "dummy22 ")
        )
    (if (= (logand s5-0 (vis-info-flag dummy14)) (vis-info-flag dummy14))
        (format #t "dummy14 ")
        )
    (if (= (logand s5-0 (vis-info-flag dummy9)) (vis-info-flag dummy9))
        (format #t "dummy9 ")
        )
    (if (= (logand s5-0 (vis-info-flag dummy10)) (vis-info-flag dummy10))
        (format #t "dummy10 ")
        )
    (if (= (logand (vis-info-flag dummy23) s5-0) (vis-info-flag dummy23))
        (format #t "dummy23 ")
        )
    (if (= (logand s5-0 (vis-info-flag dummy15)) (vis-info-flag dummy15))
        (format #t "dummy15 ")
        )
    (if (= (logand s5-0 (vis-info-flag dummy5)) (vis-info-flag dummy5))
        (format #t "dummy5 ")
        )
    (if (= (logand s5-0 (vis-info-flag dummy7)) (vis-info-flag dummy7))
        (format #t "dummy7 ")
        )
    (if (= (logand s5-0 (vis-info-flag dummy1)) (vis-info-flag dummy1))
        (format #t "dummy1 ")
        )
    (if (= (logand s5-0 (vis-info-flag dummy11)) (vis-info-flag dummy11))
        (format #t "dummy11 ")
        )
    (if (= (logand (vis-info-flag dummy28) s5-0) (vis-info-flag dummy28))
        (format #t "dummy28 ")
        )
    (if (= (logand (vis-info-flag dummy24) s5-0) (vis-info-flag dummy24))
        (format #t "dummy24 ")
        )
    (if (= (logand s5-0 (vis-info-flag dummy3)) (vis-info-flag dummy3))
        (format #t "dummy3 ")
        )
    (if (= (logand (vis-info-flag dummy16) s5-0) (vis-info-flag dummy16))
        (format #t "dummy16 ")
        )
    (if (= (logand (vis-info-flag dummy17) s5-0) (vis-info-flag dummy17))
        (format #t "dummy17 ")
        )
    (if (= (logand (vis-info-flag dummy20) s5-0) (vis-info-flag dummy20))
        (format #t "dummy20 ")
        )
    (if (= (logand s5-0 (vis-info-flag dummy12)) (vis-info-flag dummy12))
        (format #t "dummy12 ")
        )
    (if (= (logand (vis-info-flag loading) s5-0) (vis-info-flag loading))
        (format #t "loading ")
        )
    (if (= (logand (vis-info-flag dummy25) s5-0) (vis-info-flag dummy25))
        (format #t "dummy25 ")
        )
    (if (= (logand s5-0 (vis-info-flag dummy6)) (vis-info-flag dummy6))
        (format #t "dummy6 ")
        )
    (if (= (logand (vis-info-flag vis-valid) s5-0) (shl #x8000 16))
        (format #t "vis-valid ")
        )
    (if (= (logand (vis-info-flag in-iop) s5-0) (vis-info-flag in-iop))
        (format #t "in-iop ")
        )
    (if (= (logand (vis-info-flag dummy18) s5-0) (vis-info-flag dummy18))
        (format #t "dummy18 ")
        )
    (if (= (logand s5-0 (vis-info-flag dummy8)) (vis-info-flag dummy8))
        (format #t "dummy8 ")
        )
    (if (= (logand s5-0 (vis-info-flag dummy2)) (vis-info-flag dummy2))
        (format #t "dummy2 ")
        )
    (if (= (logand (vis-info-flag dummy21) s5-0) (vis-info-flag dummy21))
        (format #t "dummy21 ")
        )
    (if (= (logand s5-0 (vis-info-flag dummy13)) (vis-info-flag dummy13))
        (format #t "dummy13 ")
        )
    (if (= (logand s5-0 (vis-info-flag dummy4)) (vis-info-flag dummy4))
        (format #t "dummy4 ")
        )
    (if (= (logand (vis-info-flag dummy26) s5-0) (vis-info-flag dummy26))
        (format #t "dummy26 ")
        )
    (if (= (logand (vis-info-flag dummy27) s5-0) (vis-info-flag dummy27))
        (format #t "dummy27 ")
        )
    (if (= (logand (vis-info-flag dummy19) s5-0) (vis-info-flag dummy19))
        (format #t "dummy19 ")
        )
    (if (= (logand s5-0 (vis-info-flag dummy0)) (vis-info-flag dummy0))
        (format #t "dummy0 ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tlength: ~D~%" (-> obj length))
  (format #t "~1Tallocated-length: ~D~%" (-> obj allocated-length))
  (format #t "~1Tdictionary-length: ~D~%" (-> obj dictionary-length))
  (format #t "~1Tdictionary: #x~X~%" (-> obj dictionary))
  (format #t "~1Tstring-block: #x~X~%" (-> obj string-block))
  (format #t "~1Tramdisk: ~D~%" (-> obj ramdisk))
  (format #t "~1Tvis-bits: #x~X~%" (-> obj vis-bits))
  (format #t "~1Tcurrent-vis-string: ~D~%" (-> obj current-vis-string))
  (format #t "~1Tvis-string[0] @ #x~X~%" (-> obj vis-string))
  (label cfg-68)
  obj
  )

;; definition for method 5 of type level-vis-info
;; WARN: Return type mismatch uint vs int.
(defmethod asize-of level-vis-info ((obj level-vis-info))
  (the-as int (+ (-> level-vis-info size) (-> obj dictionary-length)))
  )

;; definition of type level-load-info
(deftype level-load-info (basic)
  ((name-list               symbol           6       :offset-assert   4)
   (index                   int16                    :offset-assert  28)
   (task-level              uint8                    :offset-assert  30)
   (name                    symbol                   :offset          4)
   (visname                 symbol                   :offset          8)
   (nickname                symbol                   :offset         12)
   (dbname                  symbol                   :offset         16)
   (taskname                symbol                   :offset         20)
   (other-name-1            symbol                   :offset         24)
   (packages                pair                     :offset-assert  32)
   (memory-mode             load-buffer-mode         :offset-assert  36)
   (music-bank              symbol                   :offset-assert  40)
   (ambient-sounds          symbol                   :offset-assert  44)
   (sound-reverb            float                    :offset-assert  48)
   (mood-func               symbol                   :offset-assert  52)
   (mood-init               symbol                   :offset-assert  56)
   (ocean                   symbol                   :offset-assert  60)
   (sky                     symbol                   :offset-assert  64)
   (use-camera-other        symbol                   :offset-assert  68)
   (part-engine-max         int32                    :offset-assert  72)
   (city-map-bits           uint64                   :offset-assert  80)
   (continues               pair                     :offset-assert  88)
   (tasks                   pair                     :offset-assert  92)
   (priority                int32                    :offset-assert  96)
   (load-commands           pair                     :offset-assert 100)
   (alt-load-commands       pair                     :offset-assert 104)
   (bsp-mask                uint64                   :offset-assert 112)
   (buzzer                  int32                    :offset-assert 120)
   (buttom-height           meters                   :offset-assert 124)
   (run-packages            pair                     :offset-assert 128)
   (prev-level              symbol                   :offset-assert 132)
   (next-level              symbol                   :offset-assert 136)
   (wait-for-load           symbol                   :offset-assert 140)
   (login-func              symbol                   :offset-assert 144)
   (activate-func           symbol                   :offset-assert 148)
   (deactivate-func         symbol                   :offset-assert 152)
   (kill-func               symbol                   :offset-assert 156)
   (borrow-size             uint16           2       :offset-assert 160)
   (borrow-level            symbol           2       :offset-assert 164)
   (borrow-display?         symbol           2       :offset-assert 172)
   (base-task-mask          task-mask                :offset-assert 180)
   (texture-anim            symbol           10      :offset-assert 184)
   (texture-anim-tfrag      symbol                   :offset        184)
   (texture-anim-pris       symbol                   :offset        188)
   (texture-anim-shrub      symbol                   :offset        192)
   (texture-anim-alpha      symbol                   :offset        196)
   (texture-anim-water      symbol                   :offset        200)
   (texture-anim-twarp      symbol                   :offset        204)
   (texture-anim-pris2      symbol                   :offset        208)
   (texture-anim-sprite     symbol                   :offset        212)
   (texture-anim-map        symbol                   :offset        216)
   (texture-anim-sky        symbol                   :offset        220)
   (draw-priority           float                    :offset-assert 224)
   (level-flags             uint32                   :offset-assert 228)
   (fog-height              float                    :offset-assert 232)
   (bigmap-id               uint32                   :offset-assert 236)
   (ocean-near-translucent? symbol                   :offset-assert 240)
   (ocean-far?              symbol                   :offset-assert 244)
   (mood-range              mood-range       :inline :offset-assert 256)
   (max-rain                float                    :offset-assert 272)
   (fog-mult                float                    :offset-assert 276)
   (ocean-alpha             float                    :offset-assert 280)
   (extra-sound-bank        pair                     :offset-assert 284)
   )
  :pack-me
  :method-count-assert 9
  :size-assert         #x120
  :flag-assert         #x900000120
  )

;; definition for method 3 of type level-load-info
(defmethod inspect level-load-info ((obj level-load-info))
  (when (not obj)
    (set! obj obj)
    (goto cfg-51)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Tname-list[6] @ #x~X~%" (&-> obj name))
  (format #t "~1Tindex: ~D~%" (-> obj index))
  (format #t "~1Ttask-level: ~D~%" (-> obj task-level))
  (format #t "~1Tname: ~A~%" (-> obj name))
  (format #t "~1Tvisname: ~A~%" (-> obj visname))
  (format #t "~1Tnickname: ~A~%" (-> obj nickname))
  (format #t "~1Tdbname: ~A~%" (-> obj dbname))
  (format #t "~1Ttaskname: ~A~%" (-> obj taskname))
  (format #t "~1Tpackages: ~A~%" (-> obj packages))
  (format #t "~1Tmemory-mode: ~D~%" (-> obj memory-mode))
  (format #t "~1Tmusic-bank: ~A~%" (-> obj music-bank))
  (format #t "~1Tambient-sounds: ~A~%" (-> obj ambient-sounds))
  (format #t "~1Tsound-reverb: ~f~%" (-> obj sound-reverb))
  (format #t "~1Tmood-func: ~A~%" (-> obj mood-func))
  (format #t "~1Tmood-init: ~A~%" (-> obj mood-init))
  (format #t "~1Tocean: ~A~%" (-> obj ocean))
  (format #t "~1Tsky: ~A~%" (-> obj sky))
  (format #t "~1Tuse-camera-other: ~A~%" (-> obj use-camera-other))
  (format #t "~1Tpart-engine-max: ~D~%" (-> obj part-engine-max))
  (format #t "~1Tcity-map-bits: ~D~%" (-> obj city-map-bits))
  (format #t "~1Tcontinues: ~A~%" (-> obj continues))
  (format #t "~1Ttasks: ~A~%" (-> obj tasks))
  (format #t "~1Tpriority: ~D~%" (-> obj priority))
  (format #t "~1Tload-commands: ~A~%" (-> obj load-commands))
  (format #t "~1Talt-load-commands: ~A~%" (-> obj alt-load-commands))
  (format #t "~1Tbsp-mask: ~D~%" (-> obj bsp-mask))
  (format #t "~1Tbuzzer: ~D~%" (-> obj buzzer))
  (format #t "~1Tbottom-height: (meters ~m)~%" (-> obj buttom-height))
  (format #t "~1Trun-packages: ~A~%" (-> obj run-packages))
  (format #t "~1Tprev-level: ~A~%" (-> obj prev-level))
  (format #t "~1Tnext-level: ~A~%" (-> obj next-level))
  (format #t "~1Twait-for-load: ~A~%" (-> obj wait-for-load))
  (format #t "~1Tlogin-func: ~A~%" (-> obj login-func))
  (format #t "~1Tactivate-func: ~A~%" (-> obj activate-func))
  (format #t "~1Tdeactivate-func: ~A~%" (-> obj deactivate-func))
  (format #t "~1Tkill-func: ~A~%" (-> obj kill-func))
  (format #t "~1Tborrow-size[2] @ #x~X~%" (-> obj borrow-size))
  (dotimes (s5-0 2)
    (format #t "~T  [~D]~1Tborrow-size: ~`integer`P~%" s5-0 (-> obj borrow-size s5-0))
    )
  (format #t "~1Tborrow-level[2] @ #x~X~%" (-> obj borrow-level))
  (dotimes (s5-1 2)
    (format #t "~T  [~D]~1Tborrow-level: ~`symbol`P~%" s5-1 (-> obj borrow-level s5-1))
    )
  (format #t "~1Tborrow-display?[2] @ #x~X~%" (-> obj borrow-display?))
  (dotimes (s5-2 2)
    (format #t "~T  [~D]~1Tborrow-display?: ~A~%" s5-2 (-> obj borrow-display? s5-2))
    )
  (format #t "~1Tbase-task-mask: #x~X : (task-mask " (-> obj base-task-mask))
  (let ((s5-3 (-> obj base-task-mask)))
    (if (= (logand s5-3 (task-mask task0)) (task-mask task0))
        (format #t "task0 ")
        )
    (if (= (logand s5-3 (task-mask task2)) (task-mask task2))
        (format #t "task2 ")
        )
    (if (= (logand s5-3 (task-mask task4)) (task-mask task4))
        (format #t "task4 ")
        )
    (if (= (logand s5-3 (task-mask task6)) (task-mask task6))
        (format #t "task6 ")
        )
    (if (= (logand s5-3 (task-mask ctywide)) (task-mask ctywide))
        (format #t "ctywide ")
        )
    (if (= (logand s5-3 (task-mask never)) (task-mask never))
        (format #t "never ")
        )
    (if (= (logand (task-mask movie1) s5-3) (task-mask movie1))
        (format #t "movie1 ")
        )
    (if (= (logand s5-3 (task-mask dummy1)) (task-mask dummy1))
        (format #t "dummy1 ")
        )
    (if (= (logand s5-3 (task-mask primary0)) (task-mask primary0))
        (format #t "primary0 ")
        )
    (if (= (logand s5-3 (task-mask task1)) (task-mask task1))
        (format #t "task1 ")
        )
    (if (= (logand s5-3 (task-mask task3)) (task-mask task3))
        (format #t "task3 ")
        )
    (if (= (logand s5-3 (task-mask task5)) (task-mask task5))
        (format #t "task5 ")
        )
    (if (= (logand s5-3 (task-mask task7)) (task-mask task7))
        (format #t "task7 ")
        )
    (if (= (logand (task-mask movie2) s5-3) (task-mask movie2))
        (format #t "movie2 ")
        )
    (if (= (logand s5-3 (task-mask dummy2)) (task-mask dummy2))
        (format #t "dummy2 ")
        )
    (if (= (logand s5-3 (task-mask done)) (task-mask done))
        (format #t "done ")
        )
    (if (= (logand s5-3 (task-mask special)) (task-mask special))
        (format #t "special ")
        )
    (if (= (logand (task-mask movie0) s5-3) (task-mask movie0))
        (format #t "movie0 ")
        )
    (if (= (logand s5-3 (task-mask dummy0)) (task-mask dummy0))
        (format #t "dummy0 ")
        )
    )
  (format #t ")~%")
  (format #t "~1Ttexture-anim[10] @ #x~X~%" (&-> obj texture-anim-tfrag))
  (format #t "~1Ttexture-anim-tfrag: ~A~%" (-> obj texture-anim-tfrag))
  (format #t "~1Ttexture-anim-pris: ~A~%" (-> obj texture-anim-pris))
  (format #t "~1Ttexture-anim-shrub: ~A~%" (-> obj texture-anim-shrub))
  (format #t "~1Ttexture-anim-alpha: ~A~%" (-> obj texture-anim-alpha))
  (format #t "~1Ttexture-anim-water: ~A~%" (-> obj texture-anim-water))
  (format #t "~1Ttexture-anim-warp: ~A~%" (-> obj texture-anim-twarp))
  (format #t "~1Ttexture-anim-pris2: ~A~%" (-> obj texture-anim-pris2))
  (format #t "~1Ttexture-anim-sprite: ~A~%" (-> obj texture-anim-sprite))
  (format #t "~1Ttexture-anim-map: ~A~%" (-> obj texture-anim-map))
  (format #t "~1Ttexture-anim-sky: ~A~%" (-> obj texture-anim-sky))
  (format #t "~1Tdraw-priority: ~f~%" (-> obj draw-priority))
  (format #t "~1Tlevel-flags: ~D~%" (-> obj level-flags))
  (format #t "~1Tfog-height: ~f~%" (-> obj fog-height))
  (format #t "~1Tbigmap-id: ~D~%" (-> obj bigmap-id))
  (format #t "~1Tocean-near-translucent?: ~A~%" (-> obj ocean-near-translucent?))
  (format #t "~1Tocean-far?: ~A~%" (-> obj ocean-far?))
  (format #t "~1Tmood-range: #<mood-range @ #x~X>~%" (-> obj mood-range))
  (format #t "~1Tmax-rain: ~f~%" (-> obj max-rain))
  (format #t "~1Tfog-mult: ~f~%" (-> obj fog-mult))
  (format #t "~1Tocean-alpha: ~f~%" (-> obj ocean-alpha))
  (format #t "~1Textra-sound-bank: ~A~%" (-> obj extra-sound-bank))
  (label cfg-51)
  obj
  )

;; definition of type login-state
(deftype login-state (basic)
  ((state int32       :offset-assert   4)
   (pos   uint32      :offset-assert   8)
   (elts  uint32      :offset-assert  12)
   (elt   drawable 16 :offset-assert  16)
   )
  :method-count-assert 9
  :size-assert         #x50
  :flag-assert         #x900000050
  )

;; definition for method 3 of type login-state
(defmethod inspect login-state ((obj login-state))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Tstate: ~D~%" (-> obj state))
  (format #t "~1Tpos: ~D~%" (-> obj pos))
  (format #t "~1Telts: ~D~%" (-> obj elts))
  (format #t "~1Telt[16] @ #x~X~%" (-> obj elt))
  (label cfg-4)
  obj
  )

;; definition of type level
(deftype level (basic)
  ((name                      symbol                                            :offset-assert   4)
   (load-name                 string                                            :offset-assert   8)
   (nickname                  string                                            :offset-assert  12)
   (index                     int32                                             :offset-assert  16)
   (status                    symbol                                            :offset-assert  20)
   (borrow-level              level                                  2          :offset-assert  24)
   (borrow-from-level         level                                             :offset-assert  32)
   (heap                      kheap                                  :inline    :offset-assert  48)
   (borrow-heap               kheap                                  2 :inline  :offset-assert  64)
   (bsp                       bsp-header                                        :offset-assert  96)
   (art-group                 load-dir-art-group                                :offset-assert 100)
   (info                      level-load-info                                   :offset-assert 104)
   (texture-page              texture-page                           18         :offset-assert 108)
   (loaded-texture-page       texture-page                           16         :offset-assert 180)
   (loaded-texture-page-count int32                                             :offset-assert 244)
   (entity                    entity-links-array                                :offset-assert 248)
   (closest-object            float                                             :offset-assert 252)
   (closest-object-array      float                                  18         :offset        252)
   (upload-size               int32                                  18         :offset        324)
   (inside-boxes              symbol                                            :offset-assert 396)
   (display?                  symbol                                            :offset-assert 400)
   (render?                   symbol                                            :offset-assert 404)
   (meta-inside?              symbol                                            :offset-assert 408)
   (force-inside?             symbol                                            :offset-assert 412)
   (mood-context              mood-context                           :inline    :offset-assert 416)
   (mood-func                 (function mood-context float int none)            :offset-assert 2384)
   (mood-init                 (function mood-context none)                      :offset-assert 2388)
   (vis-bits                  pointer                                           :offset-assert 2392)
   (all-visible?              symbol                                            :offset-assert 2396)
   (force-all-visible?        symbol                                            :offset-assert 2400)
   (linking                   symbol                                            :offset-assert 2404)
   (vis-info                  level-vis-info                         8          :offset-assert 2408)
   (vis-self-index            int32                                             :offset-assert 2440)
   (vis-adj-index             int32                                             :offset-assert 2444)
   (vis-buffer                uint8                                  2048       :offset-assert 2448)
   (mem-usage-block           memory-usage-block                                :offset-assert 4496)
   (mem-usage                 int32                                             :offset-assert 4500)
   (code-memory-start         pointer                                           :offset-assert 4504)
   (code-memory-end           pointer                                           :offset-assert 4508)
   (load-start-time           time-frame                                        :offset-assert 4512)
   (load-stop-time            time-frame                                        :offset-assert 4520)
   (load-buffer               uint32                                 2          :offset-assert 4528)
   (load-buffer-size          uint32                                            :offset-assert 4536)
   (load-buffer-last          uint32                                            :offset-assert 4540)
   (load-buffer-mode          load-buffer-mode                                  :offset-assert 4544)
   (display-start-time        time-frame                                        :offset-assert 4552)
   (memory-mask               uint32                                            :offset-assert 4560)
   (task-mask                 task-mask                                         :offset-assert 4564)
   (tfrag-gs-test             gs-test                                           :offset-assert 4568)
   (texture-dirty-masks       texture-mask                           10 :inline :offset-assert 4576)
   (texture-mask              texture-mask                           18 :inline :offset-assert 4736)
   (sky-mask                  texture-mask                           :inline    :offset-assert 5024)
   (tfrag-masks               texture-masks-array                               :offset-assert 5040)
   (tfrag-dists               pointer                                           :offset-assert 5044)
   (shrub-masks               texture-masks-array                               :offset-assert 5048)
   (shrub-dists               pointer                                           :offset-assert 5052)
   (alpha-masks               texture-masks-array                               :offset-assert 5056)
   (alpha-dists               pointer                                           :offset-assert 5060)
   (water-masks               texture-masks-array                               :offset-assert 5064)
   (water-dists               pointer                                           :offset-assert 5068)
   (tfrag-last-calls          int32                                  6          :offset-assert 5072)
   (tfrag-last-calls-u32      uint32                                 6          :offset        5072)
   (texture-anim-array        texture-anim-array                     10         :offset-assert 5096)
   (light-hash                light-hash                                        :offset-assert 5136)
   (draw-priority             float                                             :offset-assert 5140)
   (draw-index                int32                                             :offset-assert 5144)
   (part-engine               engine                                            :offset-assert 5148)
   (user-object               basic                                  4          :offset-assert 5152)
   (loaded-text-info-count    int32                                             :offset-assert 5168)
   (loaded-text-info          game-text-info                         8          :offset-assert 5172)
   (level-type                type                                              :offset-assert 5204)
   (load-order                int64                                             :offset-assert 5208)
   (pad                       int8                                   12         :offset-assert 5216)
   )
  :method-count-assert 30
  :size-assert         #x146c
  :flag-assert         #x1e0000146c
  (:methods
    (deactivate (_type_) _type_ 9)
    (is-object-visible? (_type_ int) symbol 10)
    (level-method-11 () none 11)
    (unload! (_type_) _type_ 12)
    (bsp-name (_type_) symbol 13)
    (compute-memory-usage! (_type_ symbol) memory-usage-block 14)
    (inside-boxes-check (_type_ vector) symbol 15)
    (update-vis! (_type_ level-vis-info uint (pointer uint8)) symbol 16)
    (load-continue (_type_) _type_ 17)
    (load-begin (_type_) _type_ 18)
    (login-begin (_type_) _type_ 19)
    (debug-print-region-splitbox (_type_ vector object) none 20)
    (get-art-group-by-name (_type_ string) art-group 21)
    (level-method-22 (_type_ symbol) int 22)
    (lookup-text (_type_ game-text-id symbol) string 23)
    (level-method-24 () none 24)
    (birth (_type_) _type_ 25)
    (level-status-update! (_type_ symbol) _type_ 26)
    (load-required-packages (_type_) _type_ 27)
    (init-vis-from-bsp (_type_) none 28)
    (vis-clear (_type_) none 29)
    )
  )

;; definition for method 3 of type level
(defmethod inspect level ((obj level))
  (when (not obj)
    (set! obj obj)
    (goto cfg-48)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Tname: ~A~%" (-> obj name))
  (format #t "~1Tload-name: ~A~%" (-> obj load-name))
  (format #t "~1Tnickname: ~A~%" (-> obj nickname))
  (format #t "~1Tindex: ~D~%" (-> obj index))
  (format #t "~1Tstatus: ~A~%" (-> obj status))
  (format #t "~1Tborrow-level[2] @ #x~X~%" (-> obj borrow-level))
  (dotimes (s5-0 2)
    (format #t "~T  [~D]~1Tborrow-level: ~A~%" s5-0 (-> obj borrow-level s5-0))
    )
  (format #t "~1Tborrow-from-level: ~A~%" (-> obj borrow-from-level))
  (format #t "~1Theap: #<kheap @ #x~X>~%" (-> obj heap))
  (format #t "~1Tborrow-heap[2] @ #x~X~%" (-> obj borrow-heap))
  (format #t "~1Tbsp: ~A~%" (-> obj bsp))
  (format #t "~1Tart-group: ~A~%" (-> obj art-group))
  (format #t "~1Tinfo: ~A~%" (-> obj info))
  (format #t "~1Ttexture-page[18] @ #x~X~%" (-> obj texture-page))
  (format #t "~1Tloaded-texture-page[16] @ #x~X~%" (-> obj loaded-texture-page))
  (format #t "~1Tloaded-texture-page-count: ~D~%" (-> obj loaded-texture-page-count))
  (format #t "~1Tentity: ~A~%" (-> obj entity))
  (format #t "~1Tclosest-object: (meters ~m)~%" (&-> obj closest-object))
  (format #t "~1Tupload-size[18] @ #x~X~%" (-> obj upload-size))
  (format #t "~1Tinside-boxes?: ~A~%" (-> obj inside-boxes))
  (format #t "~1Tdisplay?: ~A~%" (-> obj display?))
  (format #t "~1Trender?: ~A~%" (-> obj render?))
  (format #t "~1Tmeta-inside?: ~A~%" (-> obj meta-inside?))
  (format #t "~1Tforce-inside?: ~A~%" (-> obj force-inside?))
  (format #t "~1Tmood-context: #<mood-context @ #x~X>~%" (-> obj mood-context))
  (format #t "~1Tmood-func: ~A~%" (-> obj mood-func))
  (format #t "~1Tmood-init: ~A~%" (-> obj mood-init))
  (format #t "~1Tvis-bits: #x~X~%" (-> obj vis-bits))
  (format #t "~1Tall-visible?: ~A~%" (-> obj all-visible?))
  (format #t "~1Tforce-all-visible?: ~A~%" (-> obj force-all-visible?))
  (format #t "~1Tlinking: ~A~%" (-> obj linking))
  (format #t "~1Tvis-info[8] @ #x~X~%" (-> obj vis-info))
  (format #t "~1Tvis-self-index: ~D~%" (-> obj vis-self-index))
  (format #t "~1Tvis-adj-index: ~D~%" (-> obj vis-adj-index))
  (format #t "~1Tvis-buffer[2048] @ #x~X~%" (-> obj vis-buffer))
  (format #t "~1Tmem-usage-block: ~A~%" (-> obj mem-usage-block))
  (format #t "~1Tmem-usage: ~D~%" (-> obj mem-usage))
  (format #t "~1Tcode-memory-start: #x~X~%" (-> obj code-memory-start))
  (format #t "~1Tcode-memory-end: #x~X~%" (-> obj code-memory-end))
  (format #t "~1Tload-start-time: ~D~%" (-> obj load-start-time))
  (format #t "~1Tload-stop-time: ~D~%" (-> obj load-stop-time))
  (format #t "~1Tload-buffer[2] @ #x~X~%" (-> obj load-buffer))
  (format #t "~1Tload-buffer-size: ~D~%" (-> obj load-buffer-size))
  (format #t "~1Tload-buffer-last: ~A~%" (-> obj load-buffer-last))
  (format #t "~1Tload-buffer-mode: ~D~%" (-> obj load-buffer-mode))
  (format #t "~1Tdisplay-start-time: ~D~%" (-> obj display-start-time))
  (format #t "~1Tmemory-mask: #b~B~%" (-> obj memory-mask))
  (format #t "~1Ttask-mask: #x~X : (task-mask " (-> obj task-mask))
  (let ((s5-1 (-> obj task-mask)))
    (if (= (logand s5-1 (task-mask task0)) (task-mask task0))
        (format #t "task0 ")
        )
    (if (= (logand s5-1 (task-mask task2)) (task-mask task2))
        (format #t "task2 ")
        )
    (if (= (logand s5-1 (task-mask task4)) (task-mask task4))
        (format #t "task4 ")
        )
    (if (= (logand s5-1 (task-mask task6)) (task-mask task6))
        (format #t "task6 ")
        )
    (if (= (logand s5-1 (task-mask ctywide)) (task-mask ctywide))
        (format #t "ctywide ")
        )
    (if (= (logand s5-1 (task-mask never)) (task-mask never))
        (format #t "never ")
        )
    (if (= (logand (task-mask movie1) s5-1) (task-mask movie1))
        (format #t "movie1 ")
        )
    (if (= (logand s5-1 (task-mask dummy1)) (task-mask dummy1))
        (format #t "dummy1 ")
        )
    (if (= (logand s5-1 (task-mask primary0)) (task-mask primary0))
        (format #t "primary0 ")
        )
    (if (= (logand s5-1 (task-mask task1)) (task-mask task1))
        (format #t "task1 ")
        )
    (if (= (logand s5-1 (task-mask task3)) (task-mask task3))
        (format #t "task3 ")
        )
    (if (= (logand s5-1 (task-mask task5)) (task-mask task5))
        (format #t "task5 ")
        )
    (if (= (logand s5-1 (task-mask task7)) (task-mask task7))
        (format #t "task7 ")
        )
    (if (= (logand (task-mask movie2) s5-1) (task-mask movie2))
        (format #t "movie2 ")
        )
    (if (= (logand s5-1 (task-mask dummy2)) (task-mask dummy2))
        (format #t "dummy2 ")
        )
    (if (= (logand s5-1 (task-mask done)) (task-mask done))
        (format #t "done ")
        )
    (if (= (logand s5-1 (task-mask special)) (task-mask special))
        (format #t "special ")
        )
    (if (= (logand (task-mask movie0) s5-1) (task-mask movie0))
        (format #t "movie0 ")
        )
    (if (= (logand s5-1 (task-mask dummy0)) (task-mask dummy0))
        (format #t "dummy0 ")
        )
    )
  (format #t ")~%")
  (format #t "~1Ttfrag-gs-test: ~D~%" (-> obj tfrag-gs-test))
  (format #t "~1Ttexture-dirty-masks[10] @ #x~X~%" (-> obj texture-dirty-masks))
  (format #t "~1Ttexture-mask[18] @ #x~X~%" (-> obj texture-mask))
  (format #t "~1Tsky-mask: #<texture-mask @ #x~X>~%" (-> obj sky-mask))
  (format #t "~1Ttfrag-masks: ~A~%" (-> obj tfrag-masks))
  (format #t "~1Ttfrag-dists: #x~X~%" (-> obj tfrag-dists))
  (format #t "~1Tshrub-masks: ~A~%" (-> obj shrub-masks))
  (format #t "~1Tshrub-dists: #x~X~%" (-> obj shrub-dists))
  (format #t "~1Talpha-masks: ~A~%" (-> obj alpha-masks))
  (format #t "~1Talpha-dists: #x~X~%" (-> obj alpha-dists))
  (format #t "~1Twater-masks: ~A~%" (-> obj water-masks))
  (format #t "~1Twater-dists: #x~X~%" (-> obj water-dists))
  (format #t "~1Ttfrag-last-calls[6] @ #x~X~%" (-> obj tfrag-last-calls))
  (format #t "~1Ttexture-anim-array[10] @ #x~X~%" (-> obj texture-anim-array))
  (format #t "~1Tlight-hash: ~A~%" (-> obj light-hash))
  (format #t "~1Tdraw-priority: ~f~%" (-> obj draw-priority))
  (format #t "~1Tdraw-index: ~D~%" (-> obj draw-index))
  (format #t "~1Tpart-engine: ~A~%" (-> obj part-engine))
  (format #t "~1Tuser-object[4] @ #x~X~%" (-> obj user-object))
  (dotimes (s5-2 4)
    (format #t "~T  [~D]~1Tuser-object: ~A~%" s5-2 (-> obj user-object s5-2))
    )
  (format #t "~1Tloaded-text-info-count: ~D~%" (-> obj loaded-text-info-count))
  (format #t "~1Tloaded-text-info[8] @ #x~X~%" (-> obj loaded-text-info))
  (format #t "~1Tlevel-type: ~A~%" (-> obj level-type))
  (format #t "~1Tload-order: ~D~%" (-> obj load-order))
  (label cfg-48)
  obj
  )

;; definition of type level-group
(deftype level-group (basic)
  ((length                int32                           :offset-assert   4)
   (log-in-level-bsp      bsp-header                      :offset-assert   8)
   (loading-level         level                           :offset-assert  12)
   (entity-link           entity-links                    :offset         16)
   (border?               symbol                          :offset-assert  20)
   (vis?                  symbol                          :offset-assert  24)
   (want-level            basic                           :offset-assert  28)
   (receiving-level       basic                           :offset-assert  32)
   (load-commands         pair                            :offset-assert  36)
   (play?                 symbol                          :offset-assert  40)
   (target-pos            vector                2 :inline :offset-assert  48)
   (camera-pos            vector                2 :inline :offset-assert  80)
   (heap                  kheap                 :inline   :offset-assert 112)
   (sound-bank            basic                 4         :offset-assert 128)
   (disk-load-timing?     symbol                          :offset-assert 144)
   (load-level            basic                           :offset-assert 148)
   (load-size             uint32                          :offset-assert 152)
   (load-time             float                           :offset-assert 156)
   (load-login-time       float                           :offset-assert 160)
   (draw-level-count      int32                           :offset-assert 164)
   (draw-level            level                 7         :offset-assert 168)
   (draw-index-map        uint8                 7         :offset-assert 196)
   (load-order            uint64                          :offset-assert 208)
   (pad                   uint8                 30        :offset-assert 216)
   (level                 level                 7 :inline :offset-assert 256)
   (level0                level                 :inline   :offset        256)
   (level1                level                 :inline   :offset        5488)
   (level2                level                 :inline   :offset        10720)
   (level3                level                 :inline   :offset        15952)
   (level4                level                 :inline   :offset        21184)
   (level5                level                 :inline   :offset        26416)
   (default-level         level                 :inline   :offset        31648)
   (unknown-inline-vec-01 (inline-array vector)           :offset        32064)
   (unknown-inline-vec-02 (inline-array vector)           :offset        33712)
   (pad2                  uint8                 4         :offset-assert 36880)
   )
  :method-count-assert 31
  :size-assert         #x9014
  :flag-assert         #x1f00009014
  (:methods
    (level-get (_type_ symbol) level 9)
    (level-get-with-status (_type_ symbol) level 10)
    (get-level-by-heap-ptr-and-status (_type_ pointer symbol) level 11)
    (level-get-for-use (_type_ symbol symbol) level 12)
    (activate-levels! (_type_) int 13)
    (debug-print-entities (_type_ symbol type) none 14)
    (debug-draw-actors (_type_ symbol) none 15)
    (assign-draw-indices (_type_) none 16)
    (actors-update (_type_) none 17)
    (update-nav-meshes (_type_) none 18)
    (level-update (_type_) none 19)
    (level-get-target-inside (_type_) level 20)
    (alloc-levels-if-needed (_type_ symbol) none 21)
    (load-commands-set! (_type_ pair) none 22)
    (art-group-get-by-name (_type_ string (pointer uint32)) art-group 23)
    (alt-load-command-get-index (_type_ symbol int) pair 24)
    (update-vis-volumes (_type_) none 25)
    (update-vis-volumes-from-nav-mesh (_type_) none 26)
    (print-volume-sizes (_type_) none 27)
    (level-status (_type_ symbol) symbol 28)
    (load-in-progress? (_type_) symbol 29)
    (level-get-most-disposable (_type_) level 30)
    )
  )

;; definition for method 3 of type level-group
(defmethod inspect level-group ((obj level-group))
  (when (not obj)
    (set! obj obj)
    (goto cfg-13)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Tlength: ~D~%" (-> obj length))
  (format #t "~1Tentity-link: ~`entity-links`P~%" (-> obj entity-link))
  (format #t "~1Tborder?: ~A~%" (-> obj border?))
  (format #t "~1Tvis?: ~A~%" (-> obj vis?))
  (format #t "~1Twant-level: ~A~%" (-> obj want-level))
  (format #t "~1Treceiving-level: ~A~%" (-> obj receiving-level))
  (format #t "~1Tload-commands: ~A~%" (-> obj load-commands))
  (format #t "~1Tplay?: ~A~%" (-> obj play?))
  (format #t "~1Ttarget-pos[2] @ #x~X~%" (-> obj target-pos))
  (dotimes (s5-0 2)
    (format #t "~T  [~D]~1Ttarget-pos: ~`vector`P~%" s5-0 (-> obj target-pos s5-0))
    )
  (format #t "~1Tcamera-pos[2] @ #x~X~%" (-> obj camera-pos))
  (dotimes (s5-1 2)
    (format #t "~T  [~D]~1Tcamera-pos: ~`vector`P~%" s5-1 (-> obj camera-pos s5-1))
    )
  (format #t "~1Theap: #<kheap @ #x~X>~%" (-> obj heap))
  (format #t "~1Tsound-bank[4] @ #x~X~%" (-> obj sound-bank))
  (format #t "~1Tdisk-load-timing?: ~A~%" (-> obj disk-load-timing?))
  (format #t "~1Tload-level: ~A~%" (-> obj load-level))
  (format #t "~1Tload-size: ~D~%" (-> obj load-size))
  (format #t "~1Tload-time: ~f~%" (-> obj load-time))
  (format #t "~1Tload-login-time: ~f~%" (-> obj load-login-time))
  (format #t "~1Tdraw-level-count: ~D~%" (-> obj draw-level-count))
  (format #t "~1Tdraw-level[7] @ #x~X~%" (-> obj draw-level))
  (dotimes (s5-2 (-> obj draw-level-count))
    (format #t "~T  [~D]~1Tdraw-level: ~`object`P~%" s5-2 (-> obj draw-level s5-2))
    )
  (format #t "~1Tdraw-index-map[7] @ #x~X~%" (-> obj draw-index-map))
  (format #t "~1Tload-order: ~D~%" (-> obj load-order))
  (format #t "~1Tlevel[7] @ #x~X~%" (-> obj level0))
  (format #t "~1Tdata[7] @ #x~X~%" (-> obj level0))
  (format #t "~1Tlevel0: ~`level`P~%" (-> obj level0))
  (format #t "~1Tlevel1: ~`level`P~%" (-> obj level1))
  (format #t "~1Tlevel2: ~`level`P~%" (-> obj level2))
  (format #t "~1Tlevel3: ~`level`P~%" (-> obj level3))
  (format #t "~1Tlevel4: ~`level`P~%" (-> obj level4))
  (format #t "~1Tlevel5: ~`level`P~%" (-> obj level5))
  (format #t "~1Tlevel-default: ~`level`P~%" (-> obj default-level))
  (label cfg-13)
  obj
  )

;; failed to figure out what this is:
(when (zero? *level*)
  (set! *level* (new 'static 'level-group
                  :length 6
                  :log-in-level-bsp #f
                  :loading-level #f
                  :entity-link #f
                  :border? #f
                  :vis? #f
                  :want-level #f
                  :load-commands '()
                  :play? #f
                  :sound-bank (new 'static 'array basic 4 #f #f #f #f)
                  :disk-load-timing? #f
                  :level0 (new 'static 'level
                    :name #f
                    :status 'inactive
                    :borrow-level (new 'static 'array level 2 #f #f)
                    :borrow-from-level #f
                    :inside-boxes #f
                    :force-inside? #f
                    :linking #f
                    :level-type #f
                    )
                  :level1 (new 'static 'level
                    :name #f
                    :index 1
                    :status 'inactive
                    :borrow-level (new 'static 'array level 2 #f #f)
                    :borrow-from-level #f
                    :inside-boxes #f
                    :force-inside? #f
                    :linking #f
                    :level-type #f
                    )
                  :level2 (new 'static 'level
                    :name #f
                    :index 2
                    :status 'inactive
                    :borrow-level (new 'static 'array level 2 #f #f)
                    :borrow-from-level #f
                    :inside-boxes #f
                    :force-inside? #f
                    :linking #f
                    :level-type #f
                    )
                  :level3 (new 'static 'level
                    :name #f
                    :index 3
                    :status 'inactive
                    :borrow-level (new 'static 'array level 2 #f #f)
                    :borrow-from-level #f
                    :inside-boxes #f
                    :force-inside? #f
                    :linking #f
                    :level-type #f
                    )
                  :level4 (new 'static 'level
                    :name #f
                    :index 4
                    :status 'inactive
                    :borrow-level (new 'static 'array level 2 #f #f)
                    :borrow-from-level #f
                    :inside-boxes #f
                    :force-inside? #f
                    :linking #f
                    :level-type #f
                    )
                  :level5 (new 'static 'level
                    :name #f
                    :index 5
                    :status 'inactive
                    :borrow-level (new 'static 'array level 2 #f #f)
                    :borrow-from-level #f
                    :inside-boxes #f
                    :force-inside? #f
                    :linking #f
                    :level-type #f
                    )
                  :default-level (new 'static 'level
                    :name 'default
                    :index 6
                    :status 'reserved
                    :borrow-level (new 'static 'array level 2 #f #f)
                    :borrow-from-level #f
                    :bsp #f
                    :inside-boxes #f
                    :display? #f
                    :force-inside? #f
                    :linking #f
                    :level-type #f
                    )
                  )
        )
  (set! *draw-index* 0)
  (set! *level-index* 0)
  0
  )

;; failed to figure out what this is:
0