jak-project/test/decompiler/reference/jakx/engine/level/level-h_REF.gc

;;-*-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  4)
   (current-vis-string  uint32  4)
   (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[4] @ #x~X~%" (-> this vis-bits))
  (format #t "~1Tcurrent-vis-string[4] @ #x~X~%" (-> 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)
  ((borrow-size  uint16  3)
   (borrow-info  object  3)
   )
  )

;; 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 "~1Tborrow-size[3] @ #x~X~%" (-> this borrow-size))
  (dotimes (s5-0 3)
    (format #t "~T  [~D]~1Tborrow-size: ~`integer`P~%" s5-0 (-> this borrow-size s5-0))
    )
  (format #t "~1Tborrow-info[3] @ #x~X~%" (-> this borrow-info))
  (dotimes (s5-1 3)
    (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  4)
   (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 0))
   (taskname           symbol  :overlay-at (-> name-list 3))
   (index              int16)
   (task-level         uint8)
   (race-minimap       uint8)
   (level-flags        level-flags)
   (packages           pair)
   (memory-mode        level-memory-mode)
   (mood-func          symbol)
   (special-mood       symbol)
   (ocean              symbol)
   (ocean-height       float)
   (status-cache       uint16)
   (status-cache-sync  uint16)
   (draw-priority      float)
   (base-task-mask     task-mask)
   (continues          pair)
   (callback-list      pair)
   (borrow             level-borrow-info)
   (bottom-height      meters)
   (mood-range         mood-range)
   )
  (:methods
    (level-load-info-method-9 () none)
    (level-load-info-method-10 () none)
    )
  )

;; 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[4] @ #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 name))
  (format #t "~1Ttaskname: ~A~%" (-> this taskname))
  (format #t "~1Tindex: ~D~%" (-> this index))
  (format #t "~1Ttask-level: ~D~%" (-> this task-level))
  (format #t "~1Trace-minimap: ~D~%" (-> this race-minimap))
  (format #t "~1Tlevel-flags: ~D~%" (-> this level-flags))
  (format #t "~1Tpackages: ~A~%" (-> this packages))
  (format #t "~1Tmemory-mode: ~D~%" (-> this memory-mode))
  (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 "~1Tstatus-cache: ~D~%" (-> this status-cache))
  (format #t "~1Tstatus-cache-sync: ~D~%" (-> this status-cache-sync))
  (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 network)) (task-mask network))
        (format #t "network ")
        )
    (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 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 "~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 "~1Tmood-range: ~A~%" (-> 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                 3)
   (borrow-from-level          level)
   (heap                       kheap                 :inline)
   (borrow-heap                kheap                 3 :inline)
   (bsp                        bsp-header)
   (art-group                  load-dir-art-group)
   (info                       level-load-info)
   (level-TODO-01              int32)
   (texture-page-dir           texture-page-segment  11 :inline)
   (loaded-texture-page        texture-page          16)
   (loaded-texture-page-count  int32)
   (entity                     entity-links-array)
   (closest-object             meters                10)
   (tie-min-dist               float                 :offset 376)
   (fg-tfrag-min-dist          float)
   (fg-prim-min-dist           float)
   (fg-shrub-min-dist          float)
   (fg-warp-min-dist           float                 :offset 396)
   (fg-prim2-min-dist          float                 :offset 404)
   (upload-size                int32                 19)
   (inside-boxes?              symbol)
   (display?                   symbol)
   (render?                    symbol)
   (meta-inside?               symbol)
   (force-inside?              symbol)
   (load-id                    uint32)
   (mood-context               mood-context)
   (mood-func                  (function mood-context float int none))
   (mood-init                  (function mood-context none))
   (vis-bits                   pointer               2)
   (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                 uint32)
   (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)
   (level-TODO-003             int32)
   (level-TODO-004             int32)
   (texture-dirty-masks        texture-mask          11 :inline)
   (texture-mask               texture-mask          19 :inline)
   (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)
   (slot                       int32)
   (filter-num                 uint32)
   (filter-name                string                16)
   (filter-look                uint8                 16)
   (buffer                     kheap)
   )
  (:methods
    (level-method-9 () none)
    (level-method-10 () none)
    (level-method-11 () none)
    (level-method-12 () none)
    (level-method-13 () none)
    (level-method-14 () none)
    (level-method-15 () none)
    (level-method-16 () none)
    (level-method-17 () none)
    (level-method-18 () none)
    (level-method-19 () none)
    (level-method-20 () none)
    (level-method-21 () none)
    (level-method-22 () none)
    (level-method-23 () none)
    (level-method-24 () none)
    (level-method-25 () none)
    (level-method-26 () none)
    (level-method-27 () none)
    (level-method-28 () none)
    (level-method-29 () none)
    )
  )

;; definition for method 3 of type level
(defmethod inspect ((this level))
  (when (not this)
    (set! this this)
    (goto cfg-48)
    )
  (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[3] @ #x~X~%" (-> this borrow-level))
  (dotimes (s5-0 3)
    (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[3] @ #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-dir[11] @ #x~X~%" (-> this texture-page-dir))
  (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[19] @ #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[2] @ #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: #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 network)) (task-mask network))
        (format #t "network ")
        )
    (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 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[19] @ #x~X~%" (-> this texture-mask))
  (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 "~1Tslot: ~D~%" (-> this slot))
  (format #t "~1Tfilter-num: ~D~%" (-> this filter-num))
  (format #t "~1Tfilter-name[16] @ #x~X~%" (-> this filter-name))
  (format #t "~1Tfilter-look[16] @ #x~X~%" (-> this filter-look))
  (format #t "~1Tbuffer: #<kheap @ #x~X>~%" (-> this buffer))
  (label cfg-48)
  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)
   (border?               symbol)
   (vis?                  symbol)
   (want-level            basic)
   (receiving-level       basic)
   (load-commands         pair)
   (play?                 symbol)
   (prev-target-pos       vector            2 :inline)
   (curr-target-pos       vector            2 :inline)
   (prev-camera-pos       vector            2 :inline)
   (curr-camera-pos       vector            2 :inline)
   (heap                  kheap             :inline)
   (car-heap              kheap             :inline)
   (driver-heap           kheap             :inline)
   (cars-heap             kheap             :inline)
   (sound-bank            sound-bank-state  7 :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             19)
   (draw-index-map        uint8             19)
   (shared-ties           basic)
   (status-cache-sync     uint16)
   (load-order            uint64)
   (wide-level            level             2)
   (tfrag-login-level     basic)
   (level-group-TODO-001  int32             11)
   (level                 level             19 :inline :offset 544)
   (level0                level             :inline    :overlay-at (-> level 0))
   (level1                level             :inline    :offset 1984)
   (level2                level             :inline    :offset 3424)
   (level3                level             :inline    :offset 4864)
   (level4                level             :inline    :offset 6304)
   (level5                level             :inline    :offset 7744)
   (car0                  level             :inline    :offset 9184)
   (car1                  level             :inline    :offset 10624)
   (car2                  level             :inline    :offset 12064)
   (car3                  level             :inline    :offset 13504)
   (car4                  level             :inline    :offset 14944)
   (car5                  level             :inline    :offset 16384)
   (driver0               level             :inline    :offset 17824)
   (driver1               level             :inline    :offset 19264)
   (driver2               level             :inline    :offset 20704)
   (driver3               level             :inline    :offset 22144)
   (driver4               level             :inline    :offset 23584)
   (driver5               level             :inline    :offset 25024)
   (level-default         level             :inline    :offset 26464)
   (pad                   int32)
   )
  (:methods
    (level-group-method-9 () none)
    (level-group-method-10 () none)
    (level-group-method-11 () none)
    (level-group-method-12 () none)
    (level-group-method-13 () none)
    (level-group-method-14 () none)
    (level-group-method-15 () none)
    (level-group-method-16 () none)
    (level-group-method-17 () none)
    (level-group-method-18 () none)
    (level-group-method-19 () none)
    (level-group-method-20 () none)
    (level-group-method-21 () none)
    (level-group-method-22 () none)
    (level-group-method-23 () none)
    (level-group-method-24 () none)
    (level-group-method-25 () none)
    (level-group-method-26 () none)
    (level-group-method-27 () none)
    (level-group-method-28 () none)
    (level-group-method-29 () none)
    (level-group-method-30 () none)
    (level-group-method-31 () none)
    (level-group-method-32 () none)
    (level-group-method-33 () none)
    )
  )

;; definition for method 3 of type level-group
(defmethod inspect ((this level-group))
  (when (not this)
    (set! this this)
    (goto cfg-22)
    )
  (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 "~1Tprev-target-pos[2] @ #x~X~%" (-> this prev-target-pos))
  (dotimes (s5-0 2)
    (format #t "~T  [~D]~1Tprev-target-pos: ~`vector`P~%" s5-0 (-> this prev-target-pos s5-0))
    )
  (format #t "~1Tcurr-target-pos[2] @ #x~X~%" (-> this curr-target-pos))
  (dotimes (s5-1 2)
    (format #t "~T  [~D]~1Tcurr-target-pos: ~`vector`P~%" s5-1 (-> this curr-target-pos s5-1))
    )
  (format #t "~1Tprev-camera-pos[2] @ #x~X~%" (-> this prev-camera-pos))
  (dotimes (s5-2 2)
    (format #t "~T  [~D]~1Tprev-camera-pos: ~`vector`P~%" s5-2 (-> this prev-camera-pos s5-2))
    )
  (format #t "~1Tcurr-camera-pos[2] @ #x~X~%" (-> this curr-camera-pos))
  (dotimes (s5-3 2)
    (format #t "~T  [~D]~1Tcurr-camera-pos: ~`vector`P~%" s5-3 (-> this curr-camera-pos s5-3))
    )
  (format #t "~1Theap: #<kheap @ #x~X>~%" (-> this heap))
  (format #t "~1Tcar-heap: #<kheap @ #x~X>~%" (-> this car-heap))
  (format #t "~1Tdriver-heap: #<kheap @ #x~X>~%" (-> this driver-heap))
  (format #t "~1Tcars-heap: #<kheap @ #x~X>~%" (-> this cars-heap))
  (format #t "~1Tsound-bank[7] @ #x~X~%" (-> this sound-bank))
  (dotimes (s5-4 7)
    (format #t "~T  [~D]~1Tsound-bank: ~`sound-bank-state`P~%" s5-4 (-> this sound-bank s5-4))
    )
  (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[19] @ #x~X~%" (-> this draw-level))
  (dotimes (s5-5 (-> this draw-level-count))
    (format #t "~T  [~D]~1Tdraw-level: ~`object`P~%" s5-5 (-> this draw-level s5-5))
    )
  (format #t "~1Tdraw-index-map[19] @ #x~X~%" (-> this draw-index-map))
  (format #t "~1Tshared-ties: ~A~%" (-> this shared-ties))
  (format #t "~1Tstatus-cache-sync: ~D~%" (-> this status-cache-sync))
  (format #t "~1Tload-order: ~D~%" (-> this load-order))
  (format #t "~1Twide-level[2] @ #x~X~%" (-> this wide-level))
  (format #t "~1Ttfrag-login-level: ~A~%" (-> this tfrag-login-level))
  (format #t "~1Tlevel[19] @ #x~X~%" (-> this level))
  (format #t "~1Tdata[19] @ #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 "~1Tcar0: ~`level`P~%" (-> this car0))
  (format #t "~1Tcar1: ~`level`P~%" (-> this car1))
  (format #t "~1Tcar2: ~`level`P~%" (-> this car2))
  (format #t "~1Tcar3: ~`level`P~%" (-> this car3))
  (format #t "~1Tcar4: ~`level`P~%" (-> this car4))
  (format #t "~1Tcar5: ~`level`P~%" (-> this car5))
  (format #t "~1Tdriver0: ~`level`P~%" (-> this driver0))
  (format #t "~1Tdriver1: ~`level`P~%" (-> this driver1))
  (format #t "~1Tdriver2: ~`level`P~%" (-> this driver2))
  (format #t "~1Tdriver3: ~`level`P~%" (-> this driver3))
  (format #t "~1Tdriver4: ~`level`P~%" (-> this driver4))
  (format #t "~1Tdriver5: ~`level`P~%" (-> this driver5))
  (format #t "~1Tlevel-default: ~`level`P~%" (-> this level-default))
  (label cfg-22)
  this
  )

;; failed to figure out what this is:
(when (zero? *level*)
  (set! *level*
        (new 'static 'level-group
          :length 18
          :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 7
            (new 'static 'sound-bank-state :name #f :mode (sound-bank-mode full))
            (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 19
            (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 #f
              :index 10
              :status 'inactive
              :inside-boxes? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            (new 'static 'level
              :name #f
              :index 11
              :status 'inactive
              :inside-boxes? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            (new 'static 'level
              :name #f
              :index 12
              :status 'inactive
              :inside-boxes? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            (new 'static 'level
              :name #f
              :index 13
              :status 'inactive
              :inside-boxes? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            (new 'static 'level
              :name #f
              :index 14
              :status 'inactive
              :inside-boxes? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            (new 'static 'level
              :name #f
              :index 15
              :status 'inactive
              :inside-boxes? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            (new 'static 'level
              :name #f
              :index 16
              :status 'inactive
              :inside-boxes? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            (new 'static 'level
              :name #f
              :index 17
              :status 'inactive
              :inside-boxes? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            (new 'static 'level
              :name 'default
              :index 18
              :status 'reserved
              :bsp #f
              :inside-boxes? #f
              :display? #f
              :force-inside? #f
              :linking #f
              :level-type #f
              )
            )
          )
        )
  (set! (-> *level* sound-bank 0 str-name) (new 'global 'string 16 (the-as string #f)))
  (set! (-> *level* sound-bank 1 str-name) (new 'global 'string 16 (the-as string #f)))
  (set! (-> *level* sound-bank 2 str-name) (new 'global 'string 16 (the-as string #f)))
  (set! (-> *level* sound-bank 3 str-name) (new 'global 'string 16 (the-as string #f)))
  (set! (-> *level* sound-bank 4 str-name) (new 'global 'string 16 (the-as string #f)))
  (set! (-> *level* sound-bank 5 str-name) (new 'global 'string 16 (the-as string #f)))
  (set! (-> *level* sound-bank 6 str-name) (new 'global 'string 16 (the-as string #f)))
  (set! *draw-index* 0)
  (set! *level-index* 0)
  0
  )

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

;; definition for symbol *lobby-levels*, type (array symbol)
(define *lobby-levels* (new 'static 'boxed-array :type symbol '#f '#f))

;; definition for symbol *lobby-levels-display*, type (array symbol)
(define *lobby-levels-display* (new 'static 'boxed-array :type symbol '#f '#f))

;; definition for symbol *lobby-levels-tmp*, type (array symbol)
(define *lobby-levels-tmp* (new 'static 'boxed-array :type symbol :length 0 :allocated-length 6))

;; failed to figure out what this is:
(dotimes (v1-27 6)
  (set! (-> *lobby-levels-tmp* v1-27) #f)
  )

;; failed to figure out what this is:
0