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

;; definition of type level-vis-info
(deftype level-vis-info (basic)
  ((level               level)
   (from-level          symbol)
   (from-bsp            bsp-header)
   (flags               vis-info-flag)
   (length              uint32)
   (allocated-length    uint32)
   (dictionary-length   uint32)
   (dictionary          uint32)
   (string-block        uint32)
   (ramdisk             uint32)
   (vis-bits            uint32)
   (current-vis-string  uint32)
   (vis-string          uint32  :dynamic)
   )
  )

;; definition for method 3 of type level-vis-info
(defmethod inspect ((this level-vis-info))
  (when (not this)
    (set! this this)
    (goto cfg-68)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tlevel: ~A~%" (-> this level))
  (format #t "~1Tfrom-level: ~A~%" (-> this from-level))
  (format #t "~1Tfrom-bsp: ~A~%" (-> this from-bsp))
  (format #t "~1Tflags: #x~X : (vis-info-flag " (-> this flags))
  (let ((s5-0 (-> this 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~%" (-> this length))
  (format #t "~1Tallocated-length: ~D~%" (-> this allocated-length))
  (format #t "~1Tdictionary-length: ~D~%" (-> this dictionary-length))
  (format #t "~1Tdictionary: #x~X~%" (-> this dictionary))
  (format #t "~1Tstring-block: #x~X~%" (-> this string-block))
  (format #t "~1Tramdisk: ~D~%" (-> this ramdisk))
  (format #t "~1Tvis-bits: #x~X~%" (-> this vis-bits))
  (format #t "~1Tcurrent-vis-string: ~D~%" (-> this current-vis-string))
  (format #t "~1Tvis-string[0] @ #x~X~%" (-> this vis-string))
  (label cfg-68)
  this
  )

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

;; definition of type level-borrow-info
(deftype level-borrow-info (basic)
  ((alias        object)
   (borrow-size  uint16  5)
   (borrow-info  object  5)
   )
  )

;; definition for method 3 of type level-borrow-info
(defmethod inspect ((this level-borrow-info))
  (when (not this)
    (set! this this)
    (goto cfg-10)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Talias: ~A~%" (-> this alias))
  (format #t "~1Tborrow-size[5] @ #x~X~%" (-> this borrow-size))
  (dotimes (s5-0 5)
    (format #t "~T  [~D]~1Tborrow-size: ~`integer`P~%" s5-0 (-> this borrow-size s5-0))
    )
  (format #t "~1Tborrow-info[5] @ #x~X~%" (-> this borrow-info))
  (dotimes (s5-1 5)
    (format #t "~T  [~D]~1Tborrow-info: ~`object`P~%" s5-1 (-> this borrow-info s5-1))
    )
  (label cfg-10)
  this
  )

;; definition of type level-load-info
(deftype level-load-info (basic)
  ((name-list          symbol      6)
   (name               symbol      :overlay-at (-> name-list 0))
   (visname            symbol      :overlay-at (-> name-list 1))
   (nickname           symbol      :overlay-at (-> name-list 2))
   (dbname             symbol      :overlay-at (-> name-list 3))
   (taskname           symbol      :overlay-at (-> name-list 4))
   (index              int16)
   (task-level         uint8)
   (part-engine-max    uint8)
   (master-level       symbol)
   (level-flags        level-flags)
   (packages           pair)
   (run-packages       pair)
   (memory-mode        level-memory-mode)
   (music-bank         symbol)
   (sound-reverb       float)
   (extra-sound-bank   pair)
   (mood-func          symbol)
   (special-mood       symbol)
   (ocean              symbol)
   (ocean-height       float)
   (ocean-alpha        float)
   (status-cache       uint16)
   (status-cache-sync  uint16)
   (priority           int32)
   (draw-priority      float)
   (base-task-mask     task-mask)
   (buffer-size        uint32)
   (city-map-bits      city-map-bits)
   (bigmap-id          bigmap-id)
   (continues          pair)
   (callback-list      pair)
   (borrow             level-borrow-info)
   (bottom-height      meters)
   (fog-height         meters)
   (max-rain           float)
   (fog-mult           float)
   (mood-range         mood-range  :inline)
   )
  (:methods
    (get-callback-symbol-value-by-slot! (_type_ int) object)
    (get-callback-by-slot! (_type_ int) object)
    )
  )

;; definition for method 3 of type level-load-info
(defmethod inspect ((this level-load-info))
  (when (not this)
    (set! this this)
    (goto cfg-42)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tname-list[6] @ #x~X~%" (&-> this name))
  (format #t "~1Tname: ~A~%" (-> this name))
  (format #t "~1Tvisname: ~A~%" (-> this visname))
  (format #t "~1Tnickname: ~A~%" (-> this nickname))
  (format #t "~1Tdbname: ~A~%" (-> this dbname))
  (format #t "~1Ttaskname: ~A~%" (-> this taskname))
  (format #t "~1Tindex: ~D~%" (-> this index))
  (format #t "~1Ttask-level: ~D~%" (-> this task-level))
  (format #t "~1Tpart-engine-max: ~D~%" (-> this part-engine-max))
  (format #t "~1Tmaster-level: ~A~%" (-> this master-level))
  (format #t "~1Tlevel-flags: ~D~%" (-> this level-flags))
  (format #t "~1Tpackages: ~A~%" (-> this packages))
  (format #t "~1Trun-packages: ~A~%" (-> this run-packages))
  (format #t "~1Tmemory-mode: ~D~%" (-> this memory-mode))
  (format #t "~1Tmusic-bank: ~A~%" (-> this music-bank))
  (format #t "~1Tsound-reverb: ~f~%" (-> this sound-reverb))
  (format #t "~1Textra-sound-bank: ~A~%" (-> this extra-sound-bank))
  (format #t "~1Tmood-func: ~A~%" (-> this mood-func))
  (format #t "~1Tspecial-mood: ~A~%" (-> this special-mood))
  (format #t "~1Tocean: ~A~%" (-> this ocean))
  (format #t "~1Tocean-height: ~f~%" (-> this ocean-height))
  (format #t "~1Tocean-alpha: ~f~%" (-> this ocean-alpha))
  (format #t "~1Tstatus-cache: ~D~%" (-> this status-cache))
  (format #t "~1Tstatus-cache-sync: ~D~%" (-> this status-cache-sync))
  (format #t "~1Tpriority: ~D~%" (-> this priority))
  (format #t "~1Tdraw-priority: ~f~%" (-> this draw-priority))
  (format #t "~1Tbase-task-mask: #x~X : (task-mask " (-> this base-task-mask))
  (let ((s5-0 (-> this base-task-mask)))
    (if (= (logand s5-0 (task-mask task0)) (task-mask task0))
        (format #t "task0 ")
        )
    (if (= (logand s5-0 (task-mask task2)) (task-mask task2))
        (format #t "task2 ")
        )
    (if (= (logand s5-0 (task-mask task4)) (task-mask task4))
        (format #t "task4 ")
        )
    (if (= (logand s5-0 (task-mask task6)) (task-mask task6))
        (format #t "task6 ")
        )
    (if (= (logand s5-0 (task-mask ctywide)) (task-mask ctywide))
        (format #t "ctywide ")
        )
    (if (= (logand s5-0 (task-mask never)) (task-mask never))
        (format #t "never ")
        )
    (if (= (logand (task-mask movie1) s5-0) (task-mask movie1))
        (format #t "movie1 ")
        )
    (if (= (logand s5-0 (task-mask vehicle)) (task-mask vehicle))
        (format #t "vehicle ")
        )
    (if (= (logand s5-0 (task-mask dummy1)) (task-mask dummy1))
        (format #t "dummy1 ")
        )
    (if (= (logand s5-0 (task-mask primary0)) (task-mask primary0))
        (format #t "primary0 ")
        )
    (if (= (logand s5-0 (task-mask task1)) (task-mask task1))
        (format #t "task1 ")
        )
    (if (= (logand s5-0 (task-mask task3)) (task-mask task3))
        (format #t "task3 ")
        )
    (if (= (logand s5-0 (task-mask task5)) (task-mask task5))
        (format #t "task5 ")
        )
    (if (= (logand s5-0 (task-mask task7)) (task-mask task7))
        (format #t "task7 ")
        )
    (if (= (logand (task-mask movie2) s5-0) (task-mask movie2))
        (format #t "movie2 ")
        )
    (if (= (logand s5-0 (task-mask done)) (task-mask done))
        (format #t "done ")
        )
    (if (= (logand s5-0 (task-mask special)) (task-mask special))
        (format #t "special ")
        )
    (if (= (logand (task-mask movie0) s5-0) (task-mask movie0))
        (format #t "movie0 ")
        )
    (if (= (logand s5-0 (task-mask dummy0)) (task-mask dummy0))
        (format #t "dummy0 ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tbuffer-size: ~D~%" (-> this buffer-size))
  (format #t "~1Tcity-map-bits: ~D~%" (-> this city-map-bits))
  (format #t "~1Tbigmap-id: ~D~%" (-> this bigmap-id))
  (format #t "~1Tcontinues: ~A~%" (-> this continues))
  (format #t "~1Tcallback-list: ~A~%" (-> this callback-list))
  (format #t "~1Tborrow: ~A~%" (-> this borrow))
  (format #t "~1Tbottom-height: (meters ~m)~%" (-> this bottom-height))
  (format #t "~1Tfog-height: ~f~%" (-> this fog-height))
  (format #t "~1Tmax-rain: ~f~%" (-> this max-rain))
  (format #t "~1Tfog-mult: ~f~%" (-> this fog-mult))
  (format #t "~1Tmood-range: #<mood-range @ #x~X>~%" (-> this mood-range))
  (label cfg-42)
  this
  )

;; definition of type login-state
(deftype login-state (basic)
  ((state  int32)
   (pos    uint32)
   (elts   uint32)
   (elt    drawable  16)
   )
  )

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

;; definition of type level
(deftype level (basic)
  ((name                       symbol)
   (load-name                  symbol)
   (nickname                   symbol)
   (index                      int32)
   (status                     symbol)
   (borrow-level               level               5)
   (borrow-from-level          level)
   (heap                       kheap               :inline)
   (borrow-heap                kheap               5 :inline)
   (bsp                        bsp-header)
   (art-group                  load-dir-art-group)
   (info                       level-load-info)
   (texture-page               texture-page        20)
   (loaded-texture-page        texture-page        16)
   (loaded-texture-page-count  int32)
   (entity                     entity-links-array)
   (closest-object             meters              10)
   (tie-min-dist               float                  :offset 352)
   (fg-tfrag-min-dist          float)
   (fg-prim-min-dist           float)
   (fg-shrub-min-dist          float)
   (fg-warp-min-dist           float                  :offset 372)
   (fg-prim2-min-dist          float                  :offset 380)
   (upload-size                int32               20 :offset 388)
   (inside-boxes?              basic)
   (display?                   symbol)
   (render?                    symbol)
   (meta-inside?               symbol)
   (force-inside?              symbol)
   (load-id                    uint32)
   (mood-context               mood-context        :inline)
   (mood-func                  (function mood-context float int none))
   (mood-init                  (function mood-context none))
   (vis-bits                   pointer)
   (all-visible?               symbol)
   (force-all-visible?         symbol)
   (linking                    symbol)
   (vis-info                   level-vis-info      8)
   (vis-self-index             int32)
   (vis-adj-index              int32)
   (vis-buffer                 uint8               2048)
   (mem-usage-block            memory-usage-block)
   (mem-usage                  int32)
   (code-memory-start          pointer)
   (code-memory-end            pointer)
   (load-start-time            uint64)
   (load-stop-time             uint64)
   (load-buffer                uint32              2)
   (load-buffer-size           uint32)
   (load-buffer-last           dgo-header)
   (load-buffer-mode           level-memory-mode)
   (display-start-time         uint64)
   (memory-mask                uint32)
   (task-mask                  task-mask)
   (tfrag-gs-test              gs-test)
   (texture-dirty-masks        texture-mask        11 :inline)
   (texture-mask               texture-mask        20 :inline)
   (sky-mask                   texture-mask        :inline)
   (tfrag-masks                texture-masks-array)
   (tfrag-dists                pointer)
   (shrub-masks                texture-masks-array)
   (shrub-dists                pointer)
   (alpha-masks                texture-masks-array)
   (alpha-dists                pointer)
   (water-masks                texture-masks-array)
   (water-dists                pointer)
   (tfrag-last-calls           uint32              6)
   (texture-anim-array         texture-anim-array  11)
   (light-hash                 light-hash)
   (draw-priority              float)
   (draw-index                 int32)
   (part-engine                engine)
   (user-object                basic               4)
   (loaded-text-info-count     int32)
   (loaded-text-info           game-text-info      16)
   (level-type                 type)
   (load-order                 uint64)
   (eye-slot-lowres            uint8               11)
   (eye-slot-highres           uint8               11)
   (unknown-pad                uint8               14)
   )
  (:methods
    (deactivate (_type_) _type_)
    (unload! (_type_) _type_)
    (is-object-visible? (_type_ int) symbol)
    (level-method-12 () none)
    (bsp-name (_type_) symbol)
    (compute-memory-usage! (_type_ symbol) memory-usage-block)
    (inside-bsp? (_type_) symbol)
    (update-vis! (_type_ level-vis-info uint (pointer uint8)) symbol)
    (load-continue (_type_) _type_)
    (load-begin (_type_) _type_)
    (login-begin (_type_) _type_)
    (debug-print-region-splitbox (_type_ vector object) none)
    (get-art-group-by-name (_type_ string) art-group)
    (set-proto-vis! (_type_ symbol) int)
    (lookup-text (_type_ text-id symbol) string)
    (level-method-24 () none)
    (birth (_type_) _type_)
    (level-status-update! (_type_ symbol) _type_)
    (load-common-package (_type_) none)
    (init-vis-from-bsp (_type_) none)
    (vis-clear (_type_) none)
    )
  )

;; definition for method 3 of type level
(defmethod inspect ((this level))
  (when (not this)
    (set! this this)
    (goto cfg-54)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tname: ~A~%" (-> this name))
  (format #t "~1Tload-name: ~A~%" (-> this load-name))
  (format #t "~1Tnickname: ~A~%" (-> this nickname))
  (format #t "~1Tindex: ~D~%" (-> this index))
  (format #t "~1Tstatus: ~A~%" (-> this status))
  (format #t "~1Tborrow-level[5] @ #x~X~%" (-> this borrow-level))
  (dotimes (s5-0 5)
    (format #t "~T  [~D]~1Tborrow-level: ~A~%" s5-0 (-> this borrow-level s5-0))
    )
  (format #t "~1Tborrow-from-level: ~A~%" (-> this borrow-from-level))
  (format #t "~1Theap: #<kheap @ #x~X>~%" (-> this heap))
  (format #t "~1Tborrow-heap[5] @ #x~X~%" (-> this borrow-heap))
  (format #t "~1Tbsp: ~A~%" (-> this bsp))
  (format #t "~1Tart-group: ~A~%" (-> this art-group))
  (format #t "~1Tinfo: ~A~%" (-> this info))
  (format #t "~1Ttexture-page[20] @ #x~X~%" (-> this texture-page))
  (format #t "~1Tloaded-texture-page[16] @ #x~X~%" (-> this loaded-texture-page))
  (format #t "~1Tloaded-texture-page-count: ~D~%" (-> this loaded-texture-page-count))
  (format #t "~1Tentity: ~A~%" (-> this entity))
  (format #t "~1Tclosest-object: (meters ~m)~%" (-> this closest-object))
  (format #t "~1Tupload-size[20] @ #x~X~%" (-> this upload-size))
  (format #t "~1Tinside-boxes?: ~A~%" (-> this inside-boxes?))
  (format #t "~1Tdisplay?: ~A~%" (-> this display?))
  (format #t "~1Trender?: ~A~%" (-> this render?))
  (format #t "~1Tmeta-inside?: ~A~%" (-> this meta-inside?))
  (format #t "~1Tforce-inside?: ~A~%" (-> this force-inside?))
  (format #t "~1Tload-id: ~D~%" (-> this load-id))
  (format #t "~1Tmood-context: #<mood-context @ #x~X>~%" (-> this mood-context))
  (format #t "~1Tmood-func: ~A~%" (-> this mood-func))
  (format #t "~1Tmood-init: ~A~%" (-> this mood-init))
  (format #t "~1Tvis-bits: #x~X~%" (-> this vis-bits))
  (format #t "~1Tall-visible?: ~A~%" (-> this all-visible?))
  (format #t "~1Tforce-all-visible?: ~A~%" (-> this force-all-visible?))
  (format #t "~1Tlinking: ~A~%" (-> this linking))
  (format #t "~1Tvis-info[8] @ #x~X~%" (-> this vis-info))
  (format #t "~1Tvis-self-index: ~D~%" (-> this vis-self-index))
  (format #t "~1Tvis-adj-index: ~D~%" (-> this vis-adj-index))
  (format #t "~1Tvis-buffer[2048] @ #x~X~%" (-> this vis-buffer))
  (format #t "~1Tmem-usage-block: ~A~%" (-> this mem-usage-block))
  (format #t "~1Tmem-usage: ~D~%" (-> this mem-usage))
  (format #t "~1Tcode-memory-start: #x~X~%" (-> this code-memory-start))
  (format #t "~1Tcode-memory-end: #x~X~%" (-> this code-memory-end))
  (format #t "~1Tload-start-time: ~D~%" (-> this load-start-time))
  (format #t "~1Tload-stop-time: ~D~%" (-> this load-stop-time))
  (format #t "~1Tload-buffer[2] @ #x~X~%" (-> this load-buffer))
  (format #t "~1Tload-buffer-size: ~D~%" (-> this load-buffer-size))
  (format #t "~1Tload-buffer-last: #<dgo-header @ #x~X>~%" (-> this load-buffer-last))
  (format #t "~1Tload-buffer-mode: ~D~%" (-> this load-buffer-mode))
  (format #t "~1Tdisplay-start-time: ~D~%" (-> this display-start-time))
  (format #t "~1Tmemory-mask: #b~B~%" (-> this memory-mask))
  (format #t "~1Ttask-mask: #x~X : (task-mask " (-> this task-mask))
  (let ((s5-1 (-> this 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 vehicle)) (task-mask vehicle))
        (format #t "vehicle ")
        )
    (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 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~%" (-> this tfrag-gs-test))
  (format #t "~1Ttexture-dirty-masks[11] @ #x~X~%" (-> this texture-dirty-masks))
  (format #t "~1Ttexture-mask[20] @ #x~X~%" (-> this texture-mask))
  (format #t "~1Tsky-mask: #<texture-mask @ #x~X>~%" (-> this sky-mask))
  (format #t "~1Ttfrag-masks: ~A~%" (-> this tfrag-masks))
  (format #t "~1Ttfrag-dists: #x~X~%" (-> this tfrag-dists))
  (format #t "~1Tshrub-masks: ~A~%" (-> this shrub-masks))
  (format #t "~1Tshrub-dists: #x~X~%" (-> this shrub-dists))
  (format #t "~1Talpha-masks: ~A~%" (-> this alpha-masks))
  (format #t "~1Talpha-dists: #x~X~%" (-> this alpha-dists))
  (format #t "~1Twater-masks: ~A~%" (-> this water-masks))
  (format #t "~1Twater-dists: #x~X~%" (-> this water-dists))
  (format #t "~1Ttfrag-last-calls[6] @ #x~X~%" (-> this tfrag-last-calls))
  (format #t "~1Ttexture-anim-array[11] @ #x~X~%" (-> this texture-anim-array))
  (format #t "~1Tlight-hash: ~A~%" (-> this light-hash))
  (format #t "~1Tdraw-priority: ~f~%" (-> this draw-priority))
  (format #t "~1Tdraw-index: ~D~%" (-> this draw-index))
  (format #t "~1Tpart-engine: ~A~%" (-> this part-engine))
  (format #t "~1Tuser-object[4] @ #x~X~%" (-> this user-object))
  (dotimes (s5-2 4)
    (format #t "~T  [~D]~1Tuser-object: ~A~%" s5-2 (-> this user-object s5-2))
    )
  (format #t "~1Tloaded-text-info-count: ~D~%" (-> this loaded-text-info-count))
  (format #t "~1Tloaded-text-info[16] @ #x~X~%" (-> this loaded-text-info))
  (format #t "~1Tlevel-type: ~A~%" (-> this level-type))
  (format #t "~1Tload-order: ~D~%" (-> this load-order))
  (format #t "~1Teye-slot-lowres[11] @ #x~X~%" (-> this eye-slot-lowres))
  (dotimes (s5-3 11)
    (format #t "~T  [~D]~1Teye-slot-lowres: ~D~%" s5-3 (-> this eye-slot-lowres s5-3))
    )
  (format #t "~1Teye-slot-highres[11] @ #x~X~%" (-> this eye-slot-highres))
  (dotimes (s5-4 11)
    (format #t "~T  [~D]~1Teye-slot-highres: ~D~%" s5-4 (-> this eye-slot-highres s5-4))
    )
  (label cfg-54)
  this
  )

;; definition of type level-group
(deftype level-group (basic)
  ((length             int32)
   (log-in-level-bsp   bsp-header)
   (loading-level      level)
   (entity-link        entity-links                 :offset  16)
   (border?            symbol)
   (vis?               symbol)
   (want-level         basic)
   (receiving-level    basic)
   (load-commands      pair)
   (play?              symbol)
   (target-pos         vector            2 :inline)
   (camera-pos         vector            2 :inline)
   (heap               kheap             :inline)
   (sound-bank         sound-bank-state  6 :inline)
   (disk-load-timing?  symbol)
   (load-level         symbol)
   (load-size          uint32)
   (load-time          float)
   (load-login-time    float)
   (draw-level-count   int32)
   (draw-level         level             11)
   (draw-index-map     uint8             11)
   (status-cache-sync  uint16)
   (load-order         uint64)
   (level              level             11 :inline :offset 320)
   (level0             level             :inline    :overlay-at (-> level 0))
   (level1             level             :inline    :offset 5744)
   (level2             level             :inline    :offset 11168)
   (level3             level             :inline    :offset 16592)
   (level4             level             :inline    :offset 22016)
   (level5             level             :inline    :offset 27440)
   (level6             level             :inline    :offset 32864)
   (level7             level             :inline    :offset 38288)
   (level8             level             :inline    :offset 43712)
   (level9             level             :inline    :offset 49136)
   (level-default      level             :inline    :offset 54560)
   (pad                uint32)
   )
  (:methods
    (level-get (_type_ symbol) level)
    (level-get-with-status (_type_ symbol) level)
    (get-level-by-heap-ptr-and-status (_type_ pointer symbol) level)
    (level-get-for-use (_type_ symbol symbol) level)
    (activate-levels! (_type_) int)
    (debug-print-entities (_type_ symbol type string) none)
    (debug-draw-actors (_type_ symbol) none)
    (assign-draw-indices (_type_) none)
    (actors-update (_type_) none)
    (update-nav-meshes-method (_type_) none)
    (level-update (_type_) none)
    (level-get-target-inside (_type_) level)
    (init-level-system (_type_ symbol) none)
    (art-group-get-by-name (_type_ string (pointer level)) art-group)
    (update-vis-volumes (_type_) none)
    (level-group-method-24 (_type_) none)
    (print-volume-sizes (_type_) none)
    (level-status? (_type_ symbol symbol) symbol)
    (do-nothing (_type_) none)
    (load-in-progress? (_type_) symbol)
    (is-load-allowed? (_type_ (pointer symbol)) symbol)
    (level-get-most-disposable (_type_) level)
    )
  )

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

;; failed to figure out what this is:
(when (zero? *level*)
  (set! *level*
        (new 'static 'level-group
          :length 10
          :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 'inline-array sound-bank-state 6
            (new 'static 'sound-bank-state :name #f)
            (new 'static 'sound-bank-state :name #f)
            (new 'static 'sound-bank-state :name #f)
            (new 'static 'sound-bank-state :name #f)
            (new 'static 'sound-bank-state :name #f)
            (new 'static 'sound-bank-state :name #f)
            )
          :disk-load-timing? #f
          :status-cache-sync #x1
          :level (new 'static 'inline-array level 11
            (new 'static 'level :name #f :status 'inactive :inside-boxes? #f :force-inside? #f :linking #f :level-type #f)
            (new 'static 'level
              :name #f
              :index 1
              :status 'inactive
              :inside-boxes? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            (new 'static 'level
              :name #f
              :index 2
              :status 'inactive
              :inside-boxes? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            (new 'static 'level
              :name #f
              :index 3
              :status 'inactive
              :inside-boxes? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            (new 'static 'level
              :name #f
              :index 4
              :status 'inactive
              :inside-boxes? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            (new 'static 'level
              :name #f
              :index 5
              :status 'inactive
              :inside-boxes? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            (new 'static 'level
              :name #f
              :index 6
              :status 'inactive
              :inside-boxes? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            (new 'static 'level
              :name #f
              :index 7
              :status 'inactive
              :inside-boxes? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            (new 'static 'level
              :name #f
              :index 8
              :status 'inactive
              :inside-boxes? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            (new 'static 'level
              :name #f
              :index 9
              :status 'inactive
              :inside-boxes? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            (new 'static 'level
              :name 'default
              :index 10
              :status 'reserved
              :bsp #f
              :inside-boxes? #f
              :display? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            )
          )
        )
  (set! *draw-index* 0)
  (set! *level-index* 0)
  0
  )

;; definition for symbol *city-mode*, type symbol
(define *city-mode* #f)