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

;; this file is debug only
(declare-file (debug))

;; definition for symbol *editable-temp-id*, type int
(define *editable-temp-id* 0)

;; definition for function editable-command->string
(defun editable-command->string ((arg0 editable-command))
  (case arg0
    (((editable-command insert-entity))
     "insert-entity"
     )
    (((editable-command print-region-info))
     "print-region-info"
     )
    (((editable-command resize))
     "resize"
     )
    (((editable-command insert-face))
     "insert-face"
     )
    (((editable-command select-one))
     "select-one"
     )
    (((editable-command update-game))
     "update-game"
     )
    (((editable-command region-set))
     "region-set"
     )
    (((editable-command select-all))
     "select-all"
     )
    (((editable-command region-add))
     "region-add"
     )
    (((editable-command flip-side))
     "flip-side"
     )
    (((editable-command drag-resize))
     "drag-resize"
     )
    (((editable-command select-current-prim))
     "select-current-prim"
     )
    (((editable-command edit-plane-set))
     "edit-plane-set"
     )
    (((editable-command edit-plane-clear))
     "edit-plane-clear"
     )
    (((editable-command kill))
     "kill"
     )
    (((editable-command delete-region))
     "delete-region"
     )
    (((editable-command select-region))
     "select-region"
     )
    (((editable-command camera-tumble))
     "camera-tumble"
     )
    (((editable-command select-current-face))
     "select-current-face"
     )
    (((editable-command snap-xz))
     "snap-xz"
     )
    (((editable-command insert-sample))
     "insert-sample"
     )
    (((editable-command camera-xy))
     "camera-xy"
     )
    (((editable-command pick-loc))
     "pick-loc"
     )
    (((editable-command select-face))
     "select-face"
     )
    (((editable-command rotate-level))
     "rotate-level"
     )
    (((editable-command pick-yes-no))
     "pick-yes-no"
     )
    (((editable-command translate-y-level))
     "translate-y-level"
     )
    (((editable-command save))
     "save"
     )
    (((editable-command copy-region))
     "copy-region"
     )
    (((editable-command cancel))
     "cancel"
     )
    (((editable-command insert-light))
     "insert-light"
     )
    (((editable-command drag-move-z))
     "drag-move-z"
     )
    (((editable-command exit))
     "exit"
     )
    (((editable-command drag-move-y))
     "drag-move-y"
     )
    (((editable-command drag-move-xy))
     "drag-move-xy"
     )
    (((editable-command select-prim))
     "select-prim"
     )
    (((editable-command none))
     "none"
     )
    (((editable-command delete))
     "delete"
     )
    (((editable-command drag-move-x))
     "drag-move-x"
     )
    (((editable-command insert-plane))
     "insert-plane"
     )
    (((editable-command insert-sphere))
     "insert-sphere"
     )
    (((editable-command insert-point))
     "insert-point"
     )
    (((editable-command select-current-region))
     "select-current-region"
     )
    (((editable-command camera-xz))
     "camera-xz"
     )
    (((editable-command region-new))
     "region-new"
     )
    (((editable-command drag-move-xz))
     "drag-move-xz"
     )
    (((editable-command load))
     "load"
     )
    (((editable-command insert-box))
     "insert-box"
     )
    (((editable-command snap-to-ground))
     "snap-to-ground"
     )
    (((editable-command select-none))
     "select-none"
     )
    (((editable-command select-toggle))
     "select-toggle"
     )
    (((editable-command insert-sample-camera))
     "insert-sample-camera"
     )
    (((editable-command pick-target))
     "pick-target"
     )
    (((editable-command select-current-owner))
     "select-current-owner"
     )
    (((editable-command refresh-filter))
     "refresh-filter"
     )
    (((editable-command copy))
     "copy"
     )
    (((editable-command snap-y))
     "snap-y"
     )
    (else
      "*unknown*"
      )
    )
  )

;; definition for function editable-filter->string
;; WARN: Return type mismatch basic vs string.
(defun editable-filter->string ((arg0 editable-filter) (arg1 basic))
  (if (= (logand arg0 (editable-filter target)) (editable-filter target))
      (format arg1 "target ")
      )
  (if (= (logand arg0 (editable-filter city_vis)) (editable-filter city_vis))
      (format arg1 "city_vis ")
      )
  (if (= (logand arg0 (editable-filter water-command)) (editable-filter water-command))
      (format arg1 "water-command ")
      )
  (if (= (logand arg0 (editable-filter user-setting)) (editable-filter user-setting))
      (format arg1 "user-setting ")
      )
  (if (= (logand arg0 (editable-filter sample)) (editable-filter sample))
      (format arg1 "sample ")
      )
  (if (= (logand arg0 (editable-filter light)) (editable-filter light))
      (format arg1 "light ")
      )
  (if (= (logand arg0 (editable-filter part)) (editable-filter part))
      (format arg1 "part ")
      )
  (if (= (logand arg0 (editable-filter unknown)) (editable-filter unknown))
      (format arg1 "unknown ")
      )
  (if (= (logand arg0 (editable-filter entity)) (editable-filter entity))
      (format arg1 "entity ")
      )
  (if (= (logand arg0 (editable-filter data)) (editable-filter data))
      (format arg1 "data ")
      )
  (if (= (logand arg0 (editable-filter water)) (editable-filter water))
      (format arg1 "water ")
      )
  (if (= (logand arg0 (editable-filter cam-setting)) (editable-filter cam-setting))
      (format arg1 "cam-setting ")
      )
  (if (= (logand (editable-filter selected) arg0) (editable-filter selected))
      (format arg1 "selected ")
      )
  (if (= (logand arg0 (editable-filter none)) (editable-filter none))
      (format arg1 "none ")
      )
  (if (= (logand arg0 (editable-filter camera)) (editable-filter camera))
      (format arg1 "camera ")
      )
  (if (= (logand arg0 (editable-filter load)) (editable-filter load))
      (format arg1 "load ")
      )
  (if (= (logand arg0 (editable-filter sound)) (editable-filter sound))
      (format arg1 "sound ")
      )
  (the-as string arg1)
  )

;; definition of type editable-region
(deftype editable-region (basic)
  ((changed    symbol)
   (locked     symbol)
   (id         uint64)
   (filter     editable-filter)
   (tree       symbol)
   (level      string)
   (on-enter   string)
   (on-inside  string)
   (on-exit    string)
   )
  (:methods
    (new (symbol type) _type_)
    (editable-region-method-9 (_type_ editable-array int int) symbol)
    (editable-region-method-10 (_type_ int) symbol)
    (editable-region-method-11 (_type_ vector int) none)
    (editable-region-method-12 (_type_) editable-filter)
    )
  )

;; definition for method 3 of type editable-region
(defmethod inspect ((this editable-region))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tchanged: ~A~%" (-> this changed))
  (format #t "~1Tlocked: ~A~%" (-> this locked))
  (format #t "~1Tid: ~D~%" (-> this id))
  (format #t "~1Tfilter: ~D~%" (-> this filter))
  (format #t "~1Ttree: ~A~%" (-> this tree))
  (format #t "~1Tlevel: ~A~%" (-> this level))
  (format #t "~1Ton-enter: ~A~%" (-> this on-enter))
  (format #t "~1Ton-inside: ~A~%" (-> this on-inside))
  (format #t "~1Ton-exit: ~A~%" (-> this on-exit))
  (label cfg-4)
  this
  )

;; definition of type editable
(deftype editable (basic)
  ((flags   editable-flag)
   (name    string)
   (id      uint32)
   (region  editable-region)
   (owner   pair)
   )
  (:methods
    (get-color (_type_ int) rgba)
    (editable-method-10 (_type_) none)
    (editable-method-11 (_type_ vector) symbol)
    (select-editable! (_type_ symbol) none)
    (edit-get-distance (_type_ vector) float)
    (edit-get-trans (_type_) vector)
    (editable-method-15 (_type_ vector int) none)
    (edit-coord! (_type_ vector editable-flag) none)
    (editable-method-17 (_type_ vector) none)
    (editable-method-18 (_type_ vector matrix) none)
    (editable-method-19 (_type_ vector) none)
    (editable-method-20 (_type_ vector vector vector vector) none)
    (editable-method-21 (_type_ editable-region) none)
    (editable-method-22 (_type_ editable-array int int) symbol)
    (editable-method-23 (_type_) symbol)
    (editable-method-24 (_type_) none)
    (editable-method-25 (_type_ editable-array) none)
    (editable-method-26 (_type_ editable editable-array) none)
    (editable-method-27 (_type_ editable-array) editable)
    (editable-method-28 (_type_ editable-filter) none)
    (editable-method-29 (_type_ editable-filter) symbol)
    )
  )

;; definition for method 3 of type editable
(defmethod inspect ((this editable))
  (when (not this)
    (set! this this)
    (goto cfg-28)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tflags: #x~X : (editable-flag " (-> this flags))
  (let ((s5-0 (-> this flags)))
    (if (= (logand s5-0 (editable-flag no-save)) (editable-flag no-save))
        (format #t "no-save ")
        )
    (if (= (logand s5-0 (editable-flag top-set)) (editable-flag top-set))
        (format #t "top-set ")
        )
    (if (= (logand s5-0 (editable-flag orient)) (editable-flag orient))
        (format #t "orient ")
        )
    (if (= (logand s5-0 (editable-flag z)) (editable-flag z))
        (format #t "z ")
        )
    (if (= (logand s5-0 (editable-flag y)) (editable-flag y))
        (format #t "y ")
        )
    (if (= (logand s5-0 (editable-flag x)) (editable-flag x))
        (format #t "x ")
        )
    (if (= (logand s5-0 (editable-flag changed)) (editable-flag changed))
        (format #t "changed ")
        )
    (if (= (logand s5-0 (editable-flag no-plane-snap)) (editable-flag no-plane-snap))
        (format #t "no-plane-snap ")
        )
    (if (= (logand s5-0 (editable-flag mark)) (editable-flag mark))
        (format #t "mark ")
        )
    (if (= (logand s5-0 (editable-flag bot-set)) (editable-flag bot-set))
        (format #t "bot-set ")
        )
    (if (= (logand s5-0 (editable-flag selected)) (editable-flag selected))
        (format #t "selected ")
        )
    (if (= (logand s5-0 (editable-flag no-update)) (editable-flag no-update))
        (format #t "no-update ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tname: ~A~%" (-> this name))
  (format #t "~1Tid: ~D~%" (-> this id))
  (format #t "~1Tregion: ~A~%" (-> this region))
  (format #t "~1Towner: ~A~%" (-> this owner))
  (label cfg-28)
  this
  )

;; definition of type editable-array
(deftype editable-array (basic)
  ((allocated-length   int32)
   (length             int32)
   (region             editable-region)
   (backup-region      editable-region)
   (region-lock?       symbol)
   (move-lock?         symbol)
   (move-speed         float)
   (selection          (array editable))
   (filter             editable-filter  2)
   (target             editable)
   (target-mode        editable-command)
   (target-command     editable-command)
   (target-message     string)
   (edit-plane         editable-plane)
   (edit-plane-center  vector           :inline)
   (edit-plane-normal  vector           :inline)
   (level-offset       vector           :inline)
   (level-info-id      uint32)
   (level              uint32)
   (edit-param0        float)
   (data               editable         :dynamic)
   )
  (:methods
    (new (symbol type int) _type_)
    (editable-array-method-9 (_type_ editable-command mouse-info) symbol :behavior editable-player)
    (editable-array-method-10 (_type_ vector int) editable)
    (editable-array-method-11 (_type_) int)
    (editable-array-method-12 (_type_ editable-array) none)
    (editable-array-method-13 (_type_ editable-command editable-command string) none)
    (editable-array-method-14 (_type_ (function editable editable-region symbol) editable-region) (array editable))
    (editable-array-method-15 (_type_ editable) none)
    (editable-array-method-16 (_type_) none)
    (editable-array-method-17 (_type_ vector vector) vector)
    )
  )

;; definition for method 3 of type editable-array
(defmethod inspect ((this editable-array))
  (when (not this)
    (set! this this)
    (goto cfg-7)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tallocated-length: ~D~%" (-> this allocated-length))
  (format #t "~1Tlength: ~D~%" (-> this length))
  (format #t "~1Tregion: ~A~%" (-> this region))
  (format #t "~1Tbackup-region: ~A~%" (-> this backup-region))
  (format #t "~1Tregion-lock?: ~A~%" (-> this region-lock?))
  (format #t "~1Tmove-lock?: ~A~%" (-> this move-lock?))
  (format #t "~1Tmove-speed: ~f~%" (-> this move-speed))
  (format #t "~1Tselection: ~`basic`P~%" (-> this selection))
  (format #t "~1Tfilter[2] @ #x~X~%" (-> this filter))
  (format #t "~1Ttarget: ~A~%" (-> this target))
  (format #t "~1Ttarget-mode: ~D~%" (-> this target-mode))
  (format #t "~1Ttarget-command: ~D~%" (-> this target-command))
  (format #t "~1Ttarget-message: ~A~%" (-> this target-message))
  (format #t "~1Tedit-plane: ~A~%" (-> this edit-plane))
  (format #t "~1Tedit-plane-center: ~`vector`P~%" (-> this edit-plane-center))
  (format #t "~1Tedit-plane-normal: ~`vector`P~%" (-> this edit-plane-normal))
  (format #t "~1Tlevel-offset: ~`vector`P~%" (-> this level-offset))
  (format #t "~1Tlevel-info-id: ~D~%" (-> this level-info-id))
  (format #t "~1Tlevel: ~A~%" (-> this level))
  (format #t "~1Tedit-param0: ~f~%" (-> this edit-param0))
  (format #t "~1Tdata[0] @ #x~X~%" (-> this data))
  (dotimes (s5-0 (-> this length))
    (format #t "~T  [~D]~1Tdata: ~A~%" s5-0 (-> this data s5-0))
    )
  (label cfg-7)
  this
  )

;; definition for method 0 of type editable-array
(defmethod new editable-array ((allocation symbol) (type-to-make type) (arg0 int))
  (let ((s5-0 (object-new allocation type-to-make (the-as int (+ (-> type-to-make size) (* arg0 4))))))
    (set! (-> s5-0 allocated-length) arg0)
    (set! (-> s5-0 length) 0)
    (set! (-> s5-0 region) #f)
    (set! (-> s5-0 backup-region) #f)
    (set! (-> s5-0 region-lock?) #f)
    (set! (-> s5-0 move-lock?) #f)
    (set! (-> s5-0 target) #f)
    (set! (-> s5-0 target-command) (editable-command none))
    (set! (-> s5-0 target-message) #f)
    (set! (-> s5-0 selection)
          (the-as (array editable) ((method-of-type array new) allocation array editable arg0))
          )
    (set! (-> s5-0 edit-plane) #f)
    (set! (-> s5-0 filter 0) (editable-filter
                               none
                               unknown
                               sound
                               part
                               user-setting
                               cam-setting
                               load
                               water-command
                               city_vis
                               sample
                               light
                               entity
                               )
          )
    (set! (-> s5-0 filter 1) (editable-filter camera target water data city_vis sample light entity selected))
    (dotimes (v1-5 arg0)
      (set! (-> s5-0 data v1-5) #f)
      (set! (-> s5-0 selection v1-5) #f)
      )
    s5-0
    )
  )

;; definition of type editable-point
(deftype editable-point (editable)
  ((radius  float)
   (trans   vector  :inline)
   )
  (:methods
    (new (symbol type vector editable-region) _type_)
    )
  )

;; definition for method 3 of type editable-point
(defmethod inspect ((this editable-point))
  (when (not this)
    (set! this this)
    (goto cfg-28)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tflags: #x~X : (editable-flag " (-> this flags))
  (let ((s5-0 (-> this flags)))
    (if (= (logand s5-0 (editable-flag no-save)) (editable-flag no-save))
        (format #t "no-save ")
        )
    (if (= (logand s5-0 (editable-flag top-set)) (editable-flag top-set))
        (format #t "top-set ")
        )
    (if (= (logand s5-0 (editable-flag orient)) (editable-flag orient))
        (format #t "orient ")
        )
    (if (= (logand s5-0 (editable-flag z)) (editable-flag z))
        (format #t "z ")
        )
    (if (= (logand s5-0 (editable-flag y)) (editable-flag y))
        (format #t "y ")
        )
    (if (= (logand s5-0 (editable-flag x)) (editable-flag x))
        (format #t "x ")
        )
    (if (= (logand s5-0 (editable-flag changed)) (editable-flag changed))
        (format #t "changed ")
        )
    (if (= (logand s5-0 (editable-flag no-plane-snap)) (editable-flag no-plane-snap))
        (format #t "no-plane-snap ")
        )
    (if (= (logand s5-0 (editable-flag mark)) (editable-flag mark))
        (format #t "mark ")
        )
    (if (= (logand s5-0 (editable-flag bot-set)) (editable-flag bot-set))
        (format #t "bot-set ")
        )
    (if (= (logand s5-0 (editable-flag selected)) (editable-flag selected))
        (format #t "selected ")
        )
    (if (= (logand s5-0 (editable-flag no-update)) (editable-flag no-update))
        (format #t "no-update ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tname: ~A~%" (-> this name))
  (format #t "~1Tid: ~D~%" (-> this id))
  (format #t "~1Tregion: ~A~%" (-> this region))
  (format #t "~1Towner: ~A~%" (-> this owner))
  (format #t "~1Tradius: (meters ~m)~%" (-> this radius))
  (format #t "~1Ttrans: ~`vector`P~%" (-> this trans))
  (label cfg-28)
  this
  )

;; definition for method 0 of type editable-point
;; INFO: Used lq/sq
(defmethod new editable-point ((allocation symbol) (type-to-make type) (arg0 vector) (arg1 editable-region))
  (let ((gp-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
    (set! (-> gp-0 region) #f)
    (set! (-> gp-0 name) "undefined")
    (editable-method-21 gp-0 (cond
                               (arg1
                                 (empty)
                                 arg1
                                 )
                               (else
                                 (new 'debug 'editable-region)
                                 )
                               )
                        )
    (set! (-> gp-0 trans quad) (-> arg0 quad))
    (set! (-> gp-0 radius) 2048.0)
    (set! (-> gp-0 owner) '())
    gp-0
    )
  )

;; definition of type editable-sphere
(deftype editable-sphere (editable-point)
  ()
  (:methods
    (new (symbol type vector float editable-region) _type_)
    )
  )

;; definition for method 3 of type editable-sphere
(defmethod inspect ((this editable-sphere))
  (when (not this)
    (set! this this)
    (goto cfg-28)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tflags: #x~X : (editable-flag " (-> this flags))
  (let ((s5-0 (-> this flags)))
    (if (= (logand s5-0 (editable-flag no-save)) (editable-flag no-save))
        (format #t "no-save ")
        )
    (if (= (logand s5-0 (editable-flag top-set)) (editable-flag top-set))
        (format #t "top-set ")
        )
    (if (= (logand s5-0 (editable-flag orient)) (editable-flag orient))
        (format #t "orient ")
        )
    (if (= (logand s5-0 (editable-flag z)) (editable-flag z))
        (format #t "z ")
        )
    (if (= (logand s5-0 (editable-flag y)) (editable-flag y))
        (format #t "y ")
        )
    (if (= (logand s5-0 (editable-flag x)) (editable-flag x))
        (format #t "x ")
        )
    (if (= (logand s5-0 (editable-flag changed)) (editable-flag changed))
        (format #t "changed ")
        )
    (if (= (logand s5-0 (editable-flag no-plane-snap)) (editable-flag no-plane-snap))
        (format #t "no-plane-snap ")
        )
    (if (= (logand s5-0 (editable-flag mark)) (editable-flag mark))
        (format #t "mark ")
        )
    (if (= (logand s5-0 (editable-flag bot-set)) (editable-flag bot-set))
        (format #t "bot-set ")
        )
    (if (= (logand s5-0 (editable-flag selected)) (editable-flag selected))
        (format #t "selected ")
        )
    (if (= (logand s5-0 (editable-flag no-update)) (editable-flag no-update))
        (format #t "no-update ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tname: ~A~%" (-> this name))
  (format #t "~1Tid: ~D~%" (-> this id))
  (format #t "~1Tregion: ~A~%" (-> this region))
  (format #t "~1Towner: ~A~%" (-> this owner))
  (format #t "~1Tradius: (meters ~m)~%" (-> this radius))
  (format #t "~1Ttrans: ~`vector`P~%" (-> this trans))
  (label cfg-28)
  this
  )

;; definition for method 0 of type editable-sphere
;; INFO: Used lq/sq
(defmethod new editable-sphere ((allocation symbol) (type-to-make type) (arg0 vector) (arg1 float) (arg2 editable-region))
  (let ((s5-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
    (set! (-> s5-0 region) #f)
    (set! (-> s5-0 name) "undefined")
    (editable-method-21 s5-0 (cond
                               (arg2
                                 (empty)
                                 arg2
                                 )
                               (else
                                 (new 'debug 'editable-region)
                                 )
                               )
                        )
    (set! (-> s5-0 trans quad) (-> arg0 quad))
    (set! (-> s5-0 radius) arg1)
    (set! (-> s5-0 owner) '())
    s5-0
    )
  )

;; definition of type editable-sample
(deftype editable-sample (editable-point)
  ()
  )

;; definition for method 3 of type editable-sample
(defmethod inspect ((this editable-sample))
  (when (not this)
    (set! this this)
    (goto cfg-28)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tflags: #x~X : (editable-flag " (-> this flags))
  (let ((s5-0 (-> this flags)))
    (if (= (logand s5-0 (editable-flag no-save)) (editable-flag no-save))
        (format #t "no-save ")
        )
    (if (= (logand s5-0 (editable-flag top-set)) (editable-flag top-set))
        (format #t "top-set ")
        )
    (if (= (logand s5-0 (editable-flag orient)) (editable-flag orient))
        (format #t "orient ")
        )
    (if (= (logand s5-0 (editable-flag z)) (editable-flag z))
        (format #t "z ")
        )
    (if (= (logand s5-0 (editable-flag y)) (editable-flag y))
        (format #t "y ")
        )
    (if (= (logand s5-0 (editable-flag x)) (editable-flag x))
        (format #t "x ")
        )
    (if (= (logand s5-0 (editable-flag changed)) (editable-flag changed))
        (format #t "changed ")
        )
    (if (= (logand s5-0 (editable-flag no-plane-snap)) (editable-flag no-plane-snap))
        (format #t "no-plane-snap ")
        )
    (if (= (logand s5-0 (editable-flag mark)) (editable-flag mark))
        (format #t "mark ")
        )
    (if (= (logand s5-0 (editable-flag bot-set)) (editable-flag bot-set))
        (format #t "bot-set ")
        )
    (if (= (logand s5-0 (editable-flag selected)) (editable-flag selected))
        (format #t "selected ")
        )
    (if (= (logand s5-0 (editable-flag no-update)) (editable-flag no-update))
        (format #t "no-update ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tname: ~A~%" (-> this name))
  (format #t "~1Tid: ~D~%" (-> this id))
  (format #t "~1Tregion: ~A~%" (-> this region))
  (format #t "~1Towner: ~A~%" (-> this owner))
  (format #t "~1Tradius: (meters ~m)~%" (-> this radius))
  (format #t "~1Ttrans: ~`vector`P~%" (-> this trans))
  (label cfg-28)
  this
  )

;; definition of type editable-light
(deftype editable-light (editable-sphere)
  ((direction            vector  :inline)
   (color                vector  :inline)
   (decay-start          float)
   (ambient-point-ratio  float)
   (brightness           float)
   )
  (:methods
    (new (symbol type vector float editable-region) _type_)
    )
  )

;; definition for method 3 of type editable-light
(defmethod inspect ((this editable-light))
  (when (not this)
    (set! this this)
    (goto cfg-28)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tflags: #x~X : (editable-flag " (-> this flags))
  (let ((s5-0 (-> this flags)))
    (if (= (logand s5-0 (editable-flag no-save)) (editable-flag no-save))
        (format #t "no-save ")
        )
    (if (= (logand s5-0 (editable-flag top-set)) (editable-flag top-set))
        (format #t "top-set ")
        )
    (if (= (logand s5-0 (editable-flag orient)) (editable-flag orient))
        (format #t "orient ")
        )
    (if (= (logand s5-0 (editable-flag z)) (editable-flag z))
        (format #t "z ")
        )
    (if (= (logand s5-0 (editable-flag y)) (editable-flag y))
        (format #t "y ")
        )
    (if (= (logand s5-0 (editable-flag x)) (editable-flag x))
        (format #t "x ")
        )
    (if (= (logand s5-0 (editable-flag changed)) (editable-flag changed))
        (format #t "changed ")
        )
    (if (= (logand s5-0 (editable-flag no-plane-snap)) (editable-flag no-plane-snap))
        (format #t "no-plane-snap ")
        )
    (if (= (logand s5-0 (editable-flag mark)) (editable-flag mark))
        (format #t "mark ")
        )
    (if (= (logand s5-0 (editable-flag bot-set)) (editable-flag bot-set))
        (format #t "bot-set ")
        )
    (if (= (logand s5-0 (editable-flag selected)) (editable-flag selected))
        (format #t "selected ")
        )
    (if (= (logand s5-0 (editable-flag no-update)) (editable-flag no-update))
        (format #t "no-update ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tname: ~A~%" (-> this name))
  (format #t "~1Tid: ~D~%" (-> this id))
  (format #t "~1Tregion: ~A~%" (-> this region))
  (format #t "~1Towner: ~A~%" (-> this owner))
  (format #t "~1Tradius: (meters ~m)~%" (-> this radius))
  (format #t "~1Ttrans: ~`vector`P~%" (-> this trans))
  (format #t "~1Tdirection: ~`vector`P~%" (-> this direction))
  (format #t "~1Tcolor: ~`vector`P~%" (-> this color))
  (format #t "~1Tdecay-start: ~f~%" (-> this decay-start))
  (format #t "~1Tambient-point-ratio: ~f~%" (-> this ambient-point-ratio))
  (format #t "~1Tbrightness: ~f~%" (-> this brightness))
  (label cfg-28)
  this
  )

;; definition for method 0 of type editable-light
;; INFO: Used lq/sq
(defmethod new editable-light ((allocation symbol) (type-to-make type) (arg0 vector) (arg1 float) (arg2 editable-region))
  (let ((gp-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
    (set! (-> gp-0 region) #f)
    (editable-method-21 gp-0 (cond
                               (arg2
                                 (empty)
                                 arg2
                                 )
                               (else
                                 (new 'debug 'editable-region)
                                 )
                               )
                        )
    (set! (-> gp-0 trans quad) (-> arg0 quad))
    (set! (-> gp-0 radius) arg1)
    (set! (-> gp-0 owner) '())
    (let ((s5-1 (new 'debug 'string 32 (the-as string #f))))
      (format s5-1 "undefined-~d" *editable-temp-id*)
      (set! (-> gp-0 name) s5-1)
      )
    (set! *editable-temp-id* (+ *editable-temp-id* 1))
    (set! (-> gp-0 decay-start) 0.5)
    (set! (-> gp-0 ambient-point-ratio) 1.0)
    (set! (-> gp-0 brightness) 1.0)
    (set-vector! (-> gp-0 color) 1.0 1.0 1.0 -1.0)
    (set-vector! (-> gp-0 direction) 0.0 0.0 0.0 0.0)
    gp-0
    )
  )

;; definition of type editable-entity
(deftype editable-entity (editable-point)
  ()
  )

;; definition for method 3 of type editable-entity
(defmethod inspect ((this editable-entity))
  (when (not this)
    (set! this this)
    (goto cfg-28)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tflags: #x~X : (editable-flag " (-> this flags))
  (let ((s5-0 (-> this flags)))
    (if (= (logand s5-0 (editable-flag no-save)) (editable-flag no-save))
        (format #t "no-save ")
        )
    (if (= (logand s5-0 (editable-flag top-set)) (editable-flag top-set))
        (format #t "top-set ")
        )
    (if (= (logand s5-0 (editable-flag orient)) (editable-flag orient))
        (format #t "orient ")
        )
    (if (= (logand s5-0 (editable-flag z)) (editable-flag z))
        (format #t "z ")
        )
    (if (= (logand s5-0 (editable-flag y)) (editable-flag y))
        (format #t "y ")
        )
    (if (= (logand s5-0 (editable-flag x)) (editable-flag x))
        (format #t "x ")
        )
    (if (= (logand s5-0 (editable-flag changed)) (editable-flag changed))
        (format #t "changed ")
        )
    (if (= (logand s5-0 (editable-flag no-plane-snap)) (editable-flag no-plane-snap))
        (format #t "no-plane-snap ")
        )
    (if (= (logand s5-0 (editable-flag mark)) (editable-flag mark))
        (format #t "mark ")
        )
    (if (= (logand s5-0 (editable-flag bot-set)) (editable-flag bot-set))
        (format #t "bot-set ")
        )
    (if (= (logand s5-0 (editable-flag selected)) (editable-flag selected))
        (format #t "selected ")
        )
    (if (= (logand s5-0 (editable-flag no-update)) (editable-flag no-update))
        (format #t "no-update ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tname: ~A~%" (-> this name))
  (format #t "~1Tid: ~D~%" (-> this id))
  (format #t "~1Tregion: ~A~%" (-> this region))
  (format #t "~1Towner: ~A~%" (-> this owner))
  (format #t "~1Tradius: (meters ~m)~%" (-> this radius))
  (format #t "~1Ttrans: ~`vector`P~%" (-> this trans))
  (label cfg-28)
  this
  )

;; definition of type editable-face
(deftype editable-face (editable)
  ((length  int32)
   (normal  vector          :inline)
   (center  vector          :inline)
   (vertex  editable-point  6)
   )
  (:methods
    (new (symbol type editable-region) _type_)
    (editable-face-method-30 (_type_ (inline-array vector)) int)
    (editable-face-method-31 (_type_ vector) vector)
    )
  )

;; definition for method 3 of type editable-face
(defmethod inspect ((this editable-face))
  (when (not this)
    (set! this this)
    (goto cfg-31)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tflags: #x~X : (editable-flag " (-> this flags))
  (let ((s5-0 (-> this flags)))
    (if (= (logand s5-0 (editable-flag no-save)) (editable-flag no-save))
        (format #t "no-save ")
        )
    (if (= (logand s5-0 (editable-flag top-set)) (editable-flag top-set))
        (format #t "top-set ")
        )
    (if (= (logand s5-0 (editable-flag orient)) (editable-flag orient))
        (format #t "orient ")
        )
    (if (= (logand s5-0 (editable-flag z)) (editable-flag z))
        (format #t "z ")
        )
    (if (= (logand s5-0 (editable-flag y)) (editable-flag y))
        (format #t "y ")
        )
    (if (= (logand s5-0 (editable-flag x)) (editable-flag x))
        (format #t "x ")
        )
    (if (= (logand s5-0 (editable-flag changed)) (editable-flag changed))
        (format #t "changed ")
        )
    (if (= (logand s5-0 (editable-flag no-plane-snap)) (editable-flag no-plane-snap))
        (format #t "no-plane-snap ")
        )
    (if (= (logand s5-0 (editable-flag mark)) (editable-flag mark))
        (format #t "mark ")
        )
    (if (= (logand s5-0 (editable-flag bot-set)) (editable-flag bot-set))
        (format #t "bot-set ")
        )
    (if (= (logand s5-0 (editable-flag selected)) (editable-flag selected))
        (format #t "selected ")
        )
    (if (= (logand s5-0 (editable-flag no-update)) (editable-flag no-update))
        (format #t "no-update ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tname: ~A~%" (-> this name))
  (format #t "~1Tid: ~D~%" (-> this id))
  (format #t "~1Tregion: ~A~%" (-> this region))
  (format #t "~1Towner: ~A~%" (-> this owner))
  (format #t "~1Tlength: ~D~%" (-> this length))
  (format #t "~1Tnormal: ~`vector`P~%" (-> this normal))
  (format #t "~1Tcenter: ~`vector`P~%" (-> this center))
  (format #t "~1Tvertex[6] @ #x~X~%" (-> this vertex))
  (dotimes (s5-1 (-> this length))
    (format #t "~T  [~D]~1Tvertex: ~A~%" s5-1 (-> this vertex s5-1))
    )
  (label cfg-31)
  this
  )

;; definition for method 0 of type editable-face
(defmethod new editable-face ((allocation symbol) (type-to-make type) (arg0 editable-region))
  (let ((gp-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
    (set! (-> gp-0 region) #f)
    (set! (-> gp-0 name) "undefined")
    (editable-method-21 gp-0 (cond
                               (arg0
                                 (empty)
                                 arg0
                                 )
                               (else
                                 (new 'debug 'editable-region)
                                 )
                               )
                        )
    (set! (-> gp-0 owner) '())
    gp-0
    )
  )

;; definition of type editable-plane
(deftype editable-plane (editable)
  ((length  int32)
   (radius  float)
   (vertex  editable-point  2)
   )
  (:methods
    (new (symbol type editable-region) _type_)
    (editable-plane-method-30 (_type_ (inline-array vector)) int)
    (editable-plane-method-31 (_type_ vector) vector)
    )
  )

;; definition for method 3 of type editable-plane
(defmethod inspect ((this editable-plane))
  (when (not this)
    (set! this this)
    (goto cfg-31)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tflags: #x~X : (editable-flag " (-> this flags))
  (let ((s5-0 (-> this flags)))
    (if (= (logand s5-0 (editable-flag no-save)) (editable-flag no-save))
        (format #t "no-save ")
        )
    (if (= (logand s5-0 (editable-flag top-set)) (editable-flag top-set))
        (format #t "top-set ")
        )
    (if (= (logand s5-0 (editable-flag orient)) (editable-flag orient))
        (format #t "orient ")
        )
    (if (= (logand s5-0 (editable-flag z)) (editable-flag z))
        (format #t "z ")
        )
    (if (= (logand s5-0 (editable-flag y)) (editable-flag y))
        (format #t "y ")
        )
    (if (= (logand s5-0 (editable-flag x)) (editable-flag x))
        (format #t "x ")
        )
    (if (= (logand s5-0 (editable-flag changed)) (editable-flag changed))
        (format #t "changed ")
        )
    (if (= (logand s5-0 (editable-flag no-plane-snap)) (editable-flag no-plane-snap))
        (format #t "no-plane-snap ")
        )
    (if (= (logand s5-0 (editable-flag mark)) (editable-flag mark))
        (format #t "mark ")
        )
    (if (= (logand s5-0 (editable-flag bot-set)) (editable-flag bot-set))
        (format #t "bot-set ")
        )
    (if (= (logand s5-0 (editable-flag selected)) (editable-flag selected))
        (format #t "selected ")
        )
    (if (= (logand s5-0 (editable-flag no-update)) (editable-flag no-update))
        (format #t "no-update ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tname: ~A~%" (-> this name))
  (format #t "~1Tid: ~D~%" (-> this id))
  (format #t "~1Tregion: ~A~%" (-> this region))
  (format #t "~1Towner: ~A~%" (-> this owner))
  (format #t "~1Tlength: ~D~%" (-> this length))
  (format #t "~1Tradius: (meters ~m)~%" (-> this radius))
  (format #t "~1Tvertex[2] @ #x~X~%" (-> this vertex))
  (dotimes (s5-1 (-> this length))
    (format #t "~T  [~D]~1Tvertex: ~A~%" s5-1 (-> this vertex s5-1))
    )
  (label cfg-31)
  this
  )

;; definition for method 0 of type editable-plane
(defmethod new editable-plane ((allocation symbol) (type-to-make type) (arg0 editable-region))
  (let ((gp-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
    (set! (-> gp-0 region) #f)
    (set! (-> gp-0 name) "undefined")
    (editable-method-21 gp-0 (cond
                               (arg0
                                 (empty)
                                 arg0
                                 )
                               (else
                                 (new 'debug 'editable-region)
                                 )
                               )
                        )
    (set! (-> gp-0 owner) '())
    (set! (-> gp-0 radius) 20480.0)
    gp-0
    )
  )

;; definition of type editable-player
(deftype editable-player (process-drawable)
  ((current            editable-array)
   (select-command     function)
   (move-command       function)
   (extra-command      function)
   (left-handed        basic)
   (light-names        basic)
   (external-cam-mode  symbol)
   (command            editable-command  6)
   (close-menu-time    time-frame)
   )
  (:state-methods
    idle
    )
  (:methods
    (editable-player-method-21 (_type_) none)
    )
  )

;; definition for method 3 of type editable-player
(defmethod inspect ((this editable-player))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (let ((t9-0 (method-of-type process-drawable inspect)))
    (t9-0 this)
    )
  (format #t "~2Tcurrent: ~A~%" (-> this current))
  (format #t "~2Tselect-command: ~D~%" (-> this select-command))
  (format #t "~2Tmove-command: ~D~%" (-> this move-command))
  (format #t "~2Textra-command: ~D~%" (-> this extra-command))
  (format #t "~2Tleft-handed: ~A~%" (-> this left-handed))
  (format #t "~2Tlight-names: ~A~%" (-> this light-names))
  (format #t "~2Texternal-cam-mode: ~A~%" (-> this external-cam-mode))
  (format #t "~2Tcommand[6] @ #x~X~%" (-> this command))
  (format #t "~2Tclose-menu-time: ~D~%" (-> this close-menu-time))
  (label cfg-4)
  this
  )

;; definition of type editable-work
(deftype editable-work (basic)
  ((num-found   int16)
   (last-found  int16)
   (last-x      float)
   (last-y      float)
   (found       editable  256)
   (dists       uint32    256)
   )
  )

;; definition for method 3 of type editable-work
(defmethod inspect ((this editable-work))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tnum-found: ~D~%" (-> this num-found))
  (format #t "~1Tlast-found: ~D~%" (-> this last-found))
  (format #t "~1Tlast-x: ~f~%" (-> this last-x))
  (format #t "~1Tlast-y: ~f~%" (-> this last-y))
  (format #t "~1Tfound[256] @ #x~X~%" (-> this found))
  (format #t "~1Tdists[256] @ #x~X~%" (-> this dists))
  (label cfg-4)
  this
  )

;; definition for symbol *editable-work*, type editable-work
(define *editable-work* (new 'global 'editable-work))

;; definition for symbol *editable*, type (pointer editable-player)
(define *editable* (the-as (pointer editable-player) #f))

;; failed to figure out what this is:
0