#|
(defun method-info (m) (list (METHOD-QUALIFIERS m)(closer-mop:METHOD-LAMBDA-LIST m) (closer-mop:METHOD-SPECIALIZERS m)(closer-mop:METHOD-FUNCTION m) ;; (closer-mop:ACCESSOR-METHOD-SLOT-DEFINITION m) (DOCUMENTATION 'STANDARD-METHOD m)))
(closer-mop:METHOD-LAMBDA-LIST m) (closer-mop:METHOD-SPECIALIZERS m)(closer-mop:METHOD-FUNCTION m) ;; (closer-mop:ACCESSOR-METHOD-SLOT-DEFINITION m) (DOCUMENTATION 'STANDARD-METHOD m)))
|#

;;(quicklisp-quickstart:install)

#+clisp
  (progn    
    (load "asdf/build/asdf.lisp")
    (load "~/quicklisp/setup.lisp")
    (load "quicklisp.lisp"))

(ql:quickload "closer-mop")

(defun set-last-cdr (list ele) (let ((tail (cdr list))) (if (null tail) (rplacd list ele) (set-last-cdr tail ele))))
(defun push-non-nil (info default prop value) (unless (equal value default) (set-last-cdr info (list (list prop value)))))
(defun slot-info (m) (let ((def (list (list :name (closer-mop:slot-definition-name m)))))
 (incf *slotno*)
 (push-non-nil def :always :ordinal *slotno*)
 (push-non-nil def :instance :allocation (closer-mop:slot-definition-allocation m))
 (push-non-nil def () :initform (closer-mop:slot-definition-initform m))
 '(push-non-nil def () :initfunction (closer-mop:slot-definition-initfunction m))
 (push-non-nil def 't :type (closer-mop:slot-definition-type m))
 (push-non-nil def () :initargs (closer-mop:slot-definition-initargs m))
 (push-non-nil def () :readers (closer-mop:slot-definition-readers m))
 (push-non-nil def () :writers (closer-mop:slot-definition-writers m))
 ;;(push-non-nil def () :documentation (closer-mop:slot-definition-documentation m)) 
 def))

(defun print-psv-maybe (skip prop a b) (unless (equal b skip) (print-psv prop a b)))
(defun print-psvr (prop a b) (let ((*print-case* :downcase)(*print-readably* t)(*package* (find-package :keyword)))
   (print (list :mop-direct a prop b))))
(defun print-psv (prop a b) (unless (eq a b)
  (let ((ostr (make-array '(0) :element-type 'base-char :fill-pointer 0 :adjustable t)))
   (WITH-OUTPUT-TO-STRING (s ostr) 
    (let ((*print-case* :downcase)(*print-readably* nil)(*package* (find-package :keyword)))(print (list :mop-direct a prop b))))
    (if (search "#<" ostr) (print-psvr prop a b) (progn (princ ostr))))))

(defun print-subclasses (root &optional pre-print) (let ((class (typecase root (class root) (symbol (find-class root)) (t (class-of root))))) '(closer-mop:FINALIZE-INHERITANCE class)
 (dolist (item (mapcar #'class-name (closer-mop:class-direct-superclasses class))) (print-psv :superclass (class-name class) item)) 
 (dolist (item (mapcar #'class-name (closer-mop:class-direct-subclasses class))) (print-psv :superclass item (class-name class) ))
 (print-psv-maybe () :default-initargs (class-name class) (closer-mop:class-default-initargs class))
 (print-psv :package-name (class-name class) (package-name (symbol-package (class-name class))))
 (print-psv-maybe '(t) :precedance (class-name class) (mapcar #'class-name (cdr (closer-mop:compute-class-precedence-list class))))
 (print-psv :CLASSOF (class-name class) (class-name (CLASS-OF class)))
 (print-psv :TYPEOF (class-name class) (TYPE-OF class)) 
 ;(print-psv :documentation (class-name class) (closer-mop:class-documentation class))
 (when (equal (TYPE-OF class) 'cl:structure-class) 
     
 )
 (when pre-print (print-psv :superclass (class-name class) (class-name pre-print) ))
 (setq *slotno* 0)
 (dolist (item (mapcar #'slot-info (closer-mop:class-direct-slots class))) (print-psv :slot (class-name class) item))
 '(dolist (item (closer-mop:specializer-direct-methods class)) (print-psv :method (class-name class) item ))
 '(dolist (item (mapcar #'method-info (closer-mop:specializer-direct-methods class))) (print-psv :method (class-name class) item ))
 (dolist (item (closer-mop:class-direct-subclasses class)) (print-subclasses item class))
 (handler-case (let ((b (closer-mop:CLASS-PROTOTYPE class)))(print-psv :PROTOTYPE (class-name class) b ) )(t () ))
 ))


(print-subclasses t)

(force-output)
(terpri)



#|    


  i i i i i i i       ooooo    o        ooooooo   ooooo   ooooo
  I I I I I I I      8     8   8           8     8     o  8    8
  I  \ `+' /  I      8         8           8     8        8    8
   \  `-+-'  /       8         8           8      ooooo   8oooo
    `-__|__-'        8         8           8           8  8
        |            8     o   8           8     o     8  8
  ------+------       ooooo    8oooooo  ooo8ooo   ooooo   8

Welcome to GNU CLISP 2.49 (2010-07-07) <http://clisp.cons.org/>


  i i i i i i i       ooooo    o        ooooooo   ooooo   ooooo
  I I I I I I I      8     8   8           8     8     o  8    8
  I  \ `+' /  I      8         8           8     8        8    8
   \  `-+-'  /       8         8           8      ooooo   8oooo
    `-__|__-'        8         8           8           8  8
        |            8     o   8           8     o     8  8
  ------+------       ooooo    8oooooo  ooo8ooo   ooooo   8
  i i i i i i i       ooooo    o        ooooooo   ooooo   ooooo
  I I I I I I I      8     8   8           8     8     o  8    8
  I  \ `+' /  I      8         8           8     8        8    8
   \  `-+-'  /       8         8           8      ooooo   8oooo
    `-__|__-'        8         8           8           8  8
        |            8     o   8           8     o     8  8
  ------+------       ooooo    8oooooo  ooo8ooo   ooooo   8

Welcome to GNU CLISP 2.49 (2010-07-07) <http://clisp.cons.org/>

Copyright (c) Bruno Haible, Michael Stoll 1992, 1993
Copyright (c) Bruno Haible, Marcus Daniels 1994-1997
Copyright (c) Bruno Haible, Pierpaolo Bernardi, Sam Steingold 1998
Copyright (c) Bruno Haible, Sam Steingold 1999-2000
Copyright (c) Sam Steingold, Bruno Haible 2001-2010

Type :h and hit Enter for context help.

;; Loading file /root/.clisprc.lisp ...
;;  Loading file /root/quicklisp/setup.lisp ...
;;  Loaded file /root/quicklisp/setup.lisp
;; Loaded file /root/.clisprc.lisp
;; Loading file clisp.info ...
;;  Loading file asdf/build/asdf.lisp ...
; Renamed old ASDF package away to ASDF-2.26
;;  Loaded file asdf/build/asdf.lisp
;;  Loading file /root/quicklisp/setup.lisp ...
;;  Loaded file /root/quicklisp/setup.lisp
;;  Loading file quicklisp.lisp ...

  ==== quicklisp quickstart 2015-01-28 loaded ====

    To continue with installation, evaluate: (quicklisp-quickstart:install)

    For installation options, evaluate: (quicklisp-quickstart:help)

;;  Loaded file quicklisp.lisp
To load "closer-mop":
  Load 1 ASDF system:
    closer-mop
; Loading "closer-mop"


(:mop-direct common-lisp:symbol :superclass common-lisp:t)
(:mop-direct common-lisp:stream :superclass common-lisp:t)
(:mop-direct common-lisp:readtable :superclass common-lisp:t)
(:mop-direct common-lisp:random-state :superclass common-lisp:t)
(:mop-direct common-lisp:pathname :superclass common-lisp:t)
(:mop-direct common-lisp:package :superclass common-lisp:t)
(:mop-direct common-lisp:hash-table :superclass common-lisp:t)
(:mop-direct common-lisp:function :superclass common-lisp:t)
(:mop-direct common-lisp:character :superclass common-lisp:t)
(:mop-direct common-lisp:structure-object :superclass common-lisp:t)
(:mop-direct common-lisp:standard-object :superclass common-lisp:t)
(:mop-direct common-lisp:sequence :superclass common-lisp:t)
(:mop-direct common-lisp:array :superclass common-lisp:t)
(:mop-direct common-lisp:number :superclass common-lisp:t)
(:mop-direct common-lisp:t :package-name "COMMON-LISP")
(:mop-direct common-lisp:t :precedance common-lisp:nil)
(:mop-direct common-lisp:t :classof clos:built-in-class)
(:mop-direct common-lisp:t :typeof clos:built-in-class)
(:mop-direct common-lisp:symbol :superclass common-lisp:t)
(:mop-direct common-lisp:null :superclass common-lisp:symbol)
(:mop-direct common-lisp:symbol :package-name "COMMON-LISP")
(:mop-direct common-lisp:symbol :classof clos:built-in-class)
(:mop-direct common-lisp:symbol :typeof clos:built-in-class)
(:mop-direct common-lisp:symbol :superclass common-lisp:t)
(:mop-direct common-lisp:null :superclass common-lisp:symbol)
(:mop-direct common-lisp:null :superclass common-lisp:list)
(:mop-direct common-lisp:null :package-name "COMMON-LISP")
(:mop-direct common-lisp:null :precedance (common-lisp:symbol common-lisp:list common-lisp:sequence common-lisp:t))
(:mop-direct common-lisp:null :classof clos:built-in-class)
(:mop-direct common-lisp:null :typeof clos:built-in-class)
(:mop-direct common-lisp:null :superclass common-lisp:symbol)
(:mop-direct common-lisp:null :prototype common-lisp:nil)
(:mop-direct common-lisp:symbol :prototype common-lisp:t)
(:mop-direct common-lisp:stream :superclass common-lisp:t)
(:mop-direct gray:fundamental-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:string-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:echo-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:two-way-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:concatenated-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:broadcast-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:synonym-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:file-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:stream :package-name "COMMON-LISP")
(:mop-direct common-lisp:stream :classof clos:built-in-class)
(:mop-direct common-lisp:stream :typeof clos:built-in-class)
(:mop-direct common-lisp:stream :superclass common-lisp:t)
(:mop-direct gray:fundamental-stream :superclass common-lisp:stream)
(:mop-direct gray:fundamental-stream :superclass common-lisp:standard-object)
(:mop-direct gray:fundamental-binary-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-character-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-output-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-input-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-stream :package-name "GRAY")
(:mop-direct gray:fundamental-stream :precedance (common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct gray:fundamental-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-stream :superclass common-lisp:stream)
(:mop-direct gray:fundamental-stream :slot ((:name system::$open) (:ordinal 1) (:initform common-lisp:t) (:type common-lisp:boolean)))
(:mop-direct gray:fundamental-stream :slot ((:name system::$fasl) (:ordinal 2) (:type common-lisp:boolean)))
(:mop-direct gray:fundamental-stream :slot ((:name system::$penl) (:ordinal 3) (:type common-lisp:boolean)))
(:mop-direct gray:fundamental-binary-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-binary-output-stream :superclass gray:fundamental-binary-stream)
(:mop-direct gray:fundamental-binary-input-stream :superclass gray:fundamental-binary-stream)
(:mop-direct gray:fundamental-binary-stream :package-name "GRAY")
(:mop-direct gray:fundamental-binary-stream :precedance (gray:fundamental-stream common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct gray:fundamental-binary-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-binary-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-binary-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-binary-output-stream :superclass gray:fundamental-output-stream)
(:mop-direct gray:fundamental-binary-output-stream :superclass gray:fundamental-binary-stream)
(:mop-direct gray:fundamental-binary-output-stream :package-name "GRAY")
(:mop-direct gray:fundamental-binary-output-stream :precedance
 (gray:fundamental-output-stream gray:fundamental-binary-stream gray:fundamental-stream common-lisp:stream common-lisp:standard-object
  common-lisp:t))
(:mop-direct gray:fundamental-binary-output-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-binary-output-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-binary-output-stream :superclass gray:fundamental-binary-stream)
(:mop-direct gray:fundamental-binary-output-stream :prototype #<gray:fundamental-binary-output-stream #x0003359BF940>)
(:mop-direct gray:fundamental-binary-input-stream :superclass gray:fundamental-input-stream)
(:mop-direct gray:fundamental-binary-input-stream :superclass gray:fundamental-binary-stream)
(:mop-direct gray:fundamental-binary-input-stream :package-name "GRAY")
(:mop-direct gray:fundamental-binary-input-stream :precedance
 (gray:fundamental-input-stream gray:fundamental-binary-stream gray:fundamental-stream common-lisp:stream common-lisp:standard-object
  common-lisp:t))
(:mop-direct gray:fundamental-binary-input-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-binary-input-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-binary-input-stream :superclass gray:fundamental-binary-stream)
(:mop-direct gray:fundamental-binary-input-stream :prototype #<gray:fundamental-binary-input-stream #x0003359CAAF0>)
(:mop-direct gray:fundamental-binary-stream :prototype #<gray:fundamental-binary-stream #x0003359CD990>)
(:mop-direct gray:fundamental-character-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-character-output-stream :superclass gray:fundamental-character-stream)
(:mop-direct gray:fundamental-character-input-stream :superclass gray:fundamental-character-stream)
(:mop-direct gray:fundamental-character-stream :package-name "GRAY")
(:mop-direct gray:fundamental-character-stream :precedance
 (gray:fundamental-stream common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct gray:fundamental-character-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-character-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-character-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-character-output-stream :superclass gray:fundamental-output-stream)
(:mop-direct gray:fundamental-character-output-stream :superclass gray:fundamental-character-stream)
(:mop-direct system::html-stream-out :superclass gray:fundamental-character-output-stream)
(:mop-direct ext:fill-stream :superclass gray:fundamental-character-output-stream)
(:mop-direct gray:fundamental-character-output-stream :package-name "GRAY")
(:mop-direct gray:fundamental-character-output-stream :precedance
 (gray:fundamental-output-stream gray:fundamental-character-stream gray:fundamental-stream common-lisp:stream common-lisp:standard-object
  common-lisp:t))
(:mop-direct gray:fundamental-character-output-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-character-output-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-character-output-stream :superclass gray:fundamental-character-stream)
(:mop-direct system::html-stream-out :superclass gray:fundamental-character-output-stream)
(:mop-direct system::html-stream-out :package-name "SYSTEM")
(:mop-direct system::html-stream-out :precedance
 (gray:fundamental-character-output-stream gray:fundamental-output-stream gray:fundamental-character-stream gray:fundamental-stream
  common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct system::html-stream-out :classof clos:standard-class)
(:mop-direct system::html-stream-out :typeof clos:standard-class)
(:mop-direct system::html-stream-out :superclass gray:fundamental-character-output-stream)
(:mop-direct system::html-stream-out :slot ((:name system::target-stream) (:ordinal 1) (:type common-lisp:stream) (:initargs (:stream))))
(:mop-direct system::html-stream-out :prototype #<system::html-stream-out #x0003359E2460>)
(:mop-direct ext:fill-stream :superclass gray:fundamental-character-output-stream)
(:mop-direct system::describe-stream :superclass ext:fill-stream)
(:mop-direct ext:fill-stream :package-name "EXT")
(:mop-direct ext:fill-stream :precedance
 (gray:fundamental-character-output-stream gray:fundamental-output-stream gray:fundamental-character-stream gray:fundamental-stream
  common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct ext:fill-stream :classof clos:standard-class)
(:mop-direct ext:fill-stream :typeof clos:standard-class)
(:mop-direct ext:fill-stream :superclass gray:fundamental-character-output-stream)
(:mop-direct ext:fill-stream :slot ((:name system::target-stream) (:ordinal 1) (:type common-lisp:stream) (:initargs (:stream))))
(:mop-direct ext:fill-stream :slot
 ((:name system::buffer) (:ordinal 2)
  (:initform (common-lisp:make-array (system::right-margin) :element-type 'common-lisp:character :fill-pointer 0 :adjustable common-lisp:t))
  (:type common-lisp:string)))
(:mop-direct ext:fill-stream :slot ((:name system::inside-sexp) (:ordinal 3) (:type common-lisp:boolean)))
(:mop-direct ext:fill-stream :slot
 ((:name system::sexp-indent) (:ordinal 4) (:initform custom:*fill-indent-sexp*)
  (:type (common-lisp:or common-lisp:symbol common-lisp:integer common-lisp:function)) (:initargs (:sexp-indent))))
(:mop-direct ext:fill-stream :slot
 ((:name system::indent-var) (:ordinal 5) (:initform 0) (:type (common-lisp:or common-lisp:symbol common-lisp:integer))
  (:initargs (:text-indent))))
(:mop-direct ext:fill-stream :slot ((:name system::pending-space) (:ordinal 6) (:type common-lisp:boolean)))
(:mop-direct ext:fill-stream :slot ((:name system::current-indent) (:ordinal 7) (:initform 0) (:type common-lisp:integer)))
(:mop-direct ext:fill-stream :slot ((:name system::pending-indent) (:ordinal 8) (:type (common-lisp:or common-lisp:null common-lisp:integer))))
(:mop-direct system::describe-stream :superclass ext:fill-stream)
(:mop-direct system::describe-stream :package-name "SYSTEM")
(:mop-direct system::describe-stream :precedance
 (ext:fill-stream gray:fundamental-character-output-stream gray:fundamental-output-stream gray:fundamental-character-stream
  gray:fundamental-stream common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct system::describe-stream :classof clos:standard-class)
(:mop-direct system::describe-stream :typeof clos:standard-class)
(:mop-direct system::describe-stream :superclass ext:fill-stream)
(:mop-direct system::describe-stream :prototype #<system::describe-stream #x0003359FEFF8>)
(:mop-direct ext:fill-stream :prototype #<ext:fill-stream #x000335A01970>)
(:mop-direct gray:fundamental-character-output-stream :prototype #<gray:fundamental-character-output-stream #x000335A04470>)
(:mop-direct gray:fundamental-character-input-stream :superclass gray:fundamental-input-stream)
(:mop-direct gray:fundamental-character-input-stream :superclass gray:fundamental-character-stream)
(:mop-direct gray:fundamental-character-input-stream :package-name "GRAY")
(:mop-direct gray:fundamental-character-input-stream :precedance
 (gray:fundamental-input-stream gray:fundamental-character-stream gray:fundamental-stream common-lisp:stream common-lisp:standard-object
  common-lisp:t))
(:mop-direct gray:fundamental-character-input-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-character-input-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-character-input-stream :superclass gray:fundamental-character-stream)
(:mop-direct gray:fundamental-character-input-stream :slot ((:name system::$lastchar) (:ordinal 1)))
(:mop-direct gray:fundamental-character-input-stream :prototype #<gray:fundamental-character-input-stream #x000335A0D328>)
(:mop-direct gray:fundamental-character-stream :prototype #<gray:fundamental-character-stream #x000335A10138>)
(:mop-direct gray:fundamental-output-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-binary-output-stream :superclass gray:fundamental-output-stream)
(:mop-direct gray:fundamental-character-output-stream :superclass gray:fundamental-output-stream)
(:mop-direct gray:fundamental-output-stream :package-name "GRAY")
(:mop-direct gray:fundamental-output-stream :precedance (gray:fundamental-stream common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct gray:fundamental-output-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-output-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-output-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-binary-output-stream :superclass gray:fundamental-output-stream)
(:mop-direct gray:fundamental-binary-output-stream :superclass gray:fundamental-binary-stream)
(:mop-direct gray:fundamental-binary-output-stream :package-name "GRAY")
(:mop-direct gray:fundamental-binary-output-stream :precedance
 (gray:fundamental-output-stream gray:fundamental-binary-stream gray:fundamental-stream common-lisp:stream common-lisp:standard-object
  common-lisp:t))
(:mop-direct gray:fundamental-binary-output-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-binary-output-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-binary-output-stream :superclass gray:fundamental-output-stream)
(:mop-direct gray:fundamental-binary-output-stream :prototype #<gray:fundamental-binary-output-stream #x0003359BF940>)
(:mop-direct gray:fundamental-character-output-stream :superclass gray:fundamental-output-stream)
(:mop-direct gray:fundamental-character-output-stream :superclass gray:fundamental-character-stream)
(:mop-direct system::html-stream-out :superclass gray:fundamental-character-output-stream)
(:mop-direct ext:fill-stream :superclass gray:fundamental-character-output-stream)
(:mop-direct gray:fundamental-character-output-stream :package-name "GRAY")
(:mop-direct gray:fundamental-character-output-stream :precedance
 (gray:fundamental-output-stream gray:fundamental-character-stream gray:fundamental-stream common-lisp:stream common-lisp:standard-object
  common-lisp:t))
(:mop-direct gray:fundamental-character-output-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-character-output-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-character-output-stream :superclass gray:fundamental-output-stream)
(:mop-direct system::html-stream-out :superclass gray:fundamental-character-output-stream)
(:mop-direct system::html-stream-out :package-name "SYSTEM")
(:mop-direct system::html-stream-out :precedance
 (gray:fundamental-character-output-stream gray:fundamental-output-stream gray:fundamental-character-stream gray:fundamental-stream
  common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct system::html-stream-out :classof clos:standard-class)
(:mop-direct system::html-stream-out :typeof clos:standard-class)
(:mop-direct system::html-stream-out :superclass gray:fundamental-character-output-stream)
(:mop-direct system::html-stream-out :slot ((:name system::target-stream) (:ordinal 1) (:type common-lisp:stream) (:initargs (:stream))))
(:mop-direct system::html-stream-out :prototype #<system::html-stream-out #x0003359E2460>)
(:mop-direct ext:fill-stream :superclass gray:fundamental-character-output-stream)
(:mop-direct system::describe-stream :superclass ext:fill-stream)
(:mop-direct ext:fill-stream :package-name "EXT")
(:mop-direct ext:fill-stream :precedance
 (gray:fundamental-character-output-stream gray:fundamental-output-stream gray:fundamental-character-stream gray:fundamental-stream
  common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct ext:fill-stream :classof clos:standard-class)
(:mop-direct ext:fill-stream :typeof clos:standard-class)
(:mop-direct ext:fill-stream :superclass gray:fundamental-character-output-stream)
(:mop-direct ext:fill-stream :slot ((:name system::target-stream) (:ordinal 1) (:type common-lisp:stream) (:initargs (:stream))))
(:mop-direct ext:fill-stream :slot
 ((:name system::buffer) (:ordinal 2)
  (:initform (common-lisp:make-array (system::right-margin) :element-type 'common-lisp:character :fill-pointer 0 :adjustable common-lisp:t))
  (:type common-lisp:string)))
(:mop-direct ext:fill-stream :slot ((:name system::inside-sexp) (:ordinal 3) (:type common-lisp:boolean)))
(:mop-direct ext:fill-stream :slot
 ((:name system::sexp-indent) (:ordinal 4) (:initform custom:*fill-indent-sexp*)
  (:type (common-lisp:or common-lisp:symbol common-lisp:integer common-lisp:function)) (:initargs (:sexp-indent))))
(:mop-direct ext:fill-stream :slot
 ((:name system::indent-var) (:ordinal 5) (:initform 0) (:type (common-lisp:or common-lisp:symbol common-lisp:integer))
  (:initargs (:text-indent))))
(:mop-direct ext:fill-stream :slot ((:name system::pending-space) (:ordinal 6) (:type common-lisp:boolean)))
(:mop-direct ext:fill-stream :slot ((:name system::current-indent) (:ordinal 7) (:initform 0) (:type common-lisp:integer)))
(:mop-direct ext:fill-stream :slot ((:name system::pending-indent) (:ordinal 8) (:type (common-lisp:or common-lisp:null common-lisp:integer))))
(:mop-direct system::describe-stream :superclass ext:fill-stream)
(:mop-direct system::describe-stream :package-name "SYSTEM")
(:mop-direct system::describe-stream :precedance
 (ext:fill-stream gray:fundamental-character-output-stream gray:fundamental-output-stream gray:fundamental-character-stream
  gray:fundamental-stream common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct system::describe-stream :classof clos:standard-class)
(:mop-direct system::describe-stream :typeof clos:standard-class)
(:mop-direct system::describe-stream :superclass ext:fill-stream)
(:mop-direct system::describe-stream :prototype #<system::describe-stream #x0003359FEFF8>)
(:mop-direct ext:fill-stream :prototype #<ext:fill-stream #x000335A01970>)
(:mop-direct gray:fundamental-character-output-stream :prototype #<gray:fundamental-character-output-stream #x000335A04470>)
(:mop-direct gray:fundamental-output-stream :prototype #<gray:fundamental-output-stream #x000335A51648>)
(:mop-direct gray:fundamental-input-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-binary-input-stream :superclass gray:fundamental-input-stream)
(:mop-direct gray:fundamental-character-input-stream :superclass gray:fundamental-input-stream)
(:mop-direct gray:fundamental-input-stream :package-name "GRAY")
(:mop-direct gray:fundamental-input-stream :precedance (gray:fundamental-stream common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct gray:fundamental-input-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-input-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-input-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-binary-input-stream :superclass gray:fundamental-input-stream)
(:mop-direct gray:fundamental-binary-input-stream :superclass gray:fundamental-binary-stream)
(:mop-direct gray:fundamental-binary-input-stream :package-name "GRAY")
(:mop-direct gray:fundamental-binary-input-stream :precedance
 (gray:fundamental-input-stream gray:fundamental-binary-stream gray:fundamental-stream common-lisp:stream common-lisp:standard-object
  common-lisp:t))
(:mop-direct gray:fundamental-binary-input-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-binary-input-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-binary-input-stream :superclass gray:fundamental-input-stream)
(:mop-direct gray:fundamental-binary-input-stream :prototype #<gray:fundamental-binary-input-stream #x0003359CAAF0>)
(:mop-direct gray:fundamental-character-input-stream :superclass gray:fundamental-input-stream)
(:mop-direct gray:fundamental-character-input-stream :superclass gray:fundamental-character-stream)
(:mop-direct gray:fundamental-character-input-stream :package-name "GRAY")
(:mop-direct gray:fundamental-character-input-stream :precedance
 (gray:fundamental-input-stream gray:fundamental-character-stream gray:fundamental-stream common-lisp:stream common-lisp:standard-object
  common-lisp:t))
(:mop-direct gray:fundamental-character-input-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-character-input-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-character-input-stream :superclass gray:fundamental-input-stream)
(:mop-direct gray:fundamental-character-input-stream :slot ((:name system::$lastchar) (:ordinal 1)))
(:mop-direct gray:fundamental-character-input-stream :prototype #<gray:fundamental-character-input-stream #x000335A0D328>)
(:mop-direct gray:fundamental-input-stream :prototype #<gray:fundamental-input-stream #x000335A6A398>)
(:mop-direct gray:fundamental-stream :prototype #<gray:fundamental-stream #x000335A6D000>)
(:mop-direct common-lisp:string-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:string-stream :package-name "COMMON-LISP")
(:mop-direct common-lisp:string-stream :precedance (common-lisp:stream common-lisp:t))
(:mop-direct common-lisp:string-stream :classof clos:built-in-class)
(:mop-direct common-lisp:string-stream :typeof clos:built-in-class)
(:mop-direct common-lisp:string-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:string-stream :prototype #<output string-output-stream>)
(:mop-direct common-lisp:echo-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:echo-stream :package-name "COMMON-LISP")
(:mop-direct common-lisp:echo-stream :precedance (common-lisp:stream common-lisp:t))
(:mop-direct common-lisp:echo-stream :classof clos:built-in-class)
(:mop-direct common-lisp:echo-stream :typeof clos:built-in-class)
(:mop-direct common-lisp:echo-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:echo-stream :prototype #<io echo-stream #<input concatenated-stream> #<output broadcast-stream>>)
(:mop-direct common-lisp:two-way-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:two-way-stream :package-name "COMMON-LISP")
(:mop-direct common-lisp:two-way-stream :precedance (common-lisp:stream common-lisp:t))
(:mop-direct common-lisp:two-way-stream :classof clos:built-in-class)
(:mop-direct common-lisp:two-way-stream :typeof clos:built-in-class)
(:mop-direct common-lisp:two-way-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:two-way-stream :prototype #<io two-way-stream #<input concatenated-stream> #<output broadcast-stream>>)
(:mop-direct common-lisp:concatenated-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:concatenated-stream :package-name "COMMON-LISP")
(:mop-direct common-lisp:concatenated-stream :precedance (common-lisp:stream common-lisp:t))
(:mop-direct common-lisp:concatenated-stream :classof clos:built-in-class)
(:mop-direct common-lisp:concatenated-stream :typeof clos:built-in-class)
(:mop-direct common-lisp:concatenated-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:concatenated-stream :prototype #<input concatenated-stream>)
(:mop-direct common-lisp:broadcast-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:broadcast-stream :package-name "COMMON-LISP")
(:mop-direct common-lisp:broadcast-stream :precedance (common-lisp:stream common-lisp:t))
(:mop-direct common-lisp:broadcast-stream :classof clos:built-in-class)
(:mop-direct common-lisp:broadcast-stream :typeof clos:built-in-class)
(:mop-direct common-lisp:broadcast-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:broadcast-stream :prototype #<output broadcast-stream>)
(:mop-direct common-lisp:synonym-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:synonym-stream :package-name "COMMON-LISP")
(:mop-direct common-lisp:synonym-stream :precedance (common-lisp:stream common-lisp:t))
(:mop-direct common-lisp:synonym-stream :classof clos:built-in-class)
(:mop-direct common-lisp:synonym-stream :typeof clos:built-in-class)
(:mop-direct common-lisp:synonym-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:synonym-stream :prototype #<io synonym-stream common-lisp:*terminal-io*>)
(:mop-direct common-lisp:file-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:file-stream :package-name "COMMON-LISP")
(:mop-direct common-lisp:file-stream :precedance (common-lisp:stream common-lisp:t))
(:mop-direct common-lisp:file-stream :classof clos:built-in-class)
(:mop-direct common-lisp:file-stream :typeof clos:built-in-class)
(:mop-direct common-lisp:file-stream :superclass common-lisp:stream)
(:mop-direct common-lisp:file-stream :prototype #<closed invalid buffered file-stream common-lisp:character #P"clos-class3.fas">)
(:mop-direct common-lisp:stream :prototype common-lisp:nil)
(:mop-direct common-lisp:readtable :superclass common-lisp:t)
(:mop-direct common-lisp:readtable :package-name "COMMON-LISP")
(:mop-direct common-lisp:readtable :classof clos:built-in-class)
(:mop-direct common-lisp:readtable :typeof clos:built-in-class)
(:mop-direct common-lisp:readtable :superclass common-lisp:t)
(:mop-direct common-lisp:readtable :prototype #<readtable #x00033543ADD8>)
(:mop-direct common-lisp:random-state :superclass common-lisp:t)
(:mop-direct common-lisp:random-state :package-name "COMMON-LISP")
(:mop-direct common-lisp:random-state :classof clos:built-in-class)
(:mop-direct common-lisp:random-state :typeof clos:built-in-class)
(:mop-direct common-lisp:random-state :superclass common-lisp:t)
(:mop-direct common-lisp:random-state :prototype
 #S(common-lisp:random-state #*0111000111100101101010000100010110100110001001100000011001011001))
(:mop-direct common-lisp:pathname :superclass common-lisp:t)
(:mop-direct common-lisp:logical-pathname :superclass common-lisp:pathname)
(:mop-direct common-lisp:pathname :package-name "COMMON-LISP")
(:mop-direct common-lisp:pathname :classof clos:built-in-class)
(:mop-direct common-lisp:pathname :typeof clos:built-in-class)
(:mop-direct common-lisp:pathname :superclass common-lisp:t)
(:mop-direct common-lisp:logical-pathname :superclass common-lisp:pathname)
(:mop-direct common-lisp:logical-pathname :package-name "COMMON-LISP")
(:mop-direct common-lisp:logical-pathname :precedance (common-lisp:pathname common-lisp:t))
(:mop-direct common-lisp:logical-pathname :classof clos:built-in-class)
(:mop-direct common-lisp:logical-pathname :typeof clos:built-in-class)
(:mop-direct common-lisp:logical-pathname :superclass common-lisp:pathname)
(:mop-direct common-lisp:logical-pathname :prototype
 #S(common-lisp:logical-pathname :host "" :device :unspecific :directory (:absolute) :name common-lisp:nil :type common-lisp:nil
    :version common-lisp:nil))
(:mop-direct common-lisp:pathname :prototype #P"")
(:mop-direct common-lisp:package :superclass common-lisp:t)
(:mop-direct common-lisp:package :package-name "COMMON-LISP")
(:mop-direct common-lisp:package :classof clos:built-in-class)
(:mop-direct common-lisp:package :typeof clos:built-in-class)
(:mop-direct common-lisp:package :superclass common-lisp:t)
(:mop-direct common-lisp:package :prototype #<package keyword>)
(:mop-direct common-lisp:hash-table :superclass common-lisp:t)
(:mop-direct common-lisp:hash-table :package-name "COMMON-LISP")
(:mop-direct common-lisp:hash-table :classof clos:built-in-class)
(:mop-direct common-lisp:hash-table :typeof clos:built-in-class)
(:mop-direct common-lisp:hash-table :superclass common-lisp:t)
(:mop-direct common-lisp:hash-table :prototype #S(common-lisp:hash-table :test ext:fasthash-eq :warn-if-needs-rehash-after-gc common-lisp:t))
(:mop-direct common-lisp:function :superclass common-lisp:t)
(:mop-direct clos:funcallable-standard-object :superclass common-lisp:function)
(:mop-direct common-lisp:function :package-name "COMMON-LISP")
(:mop-direct common-lisp:function :classof clos:built-in-class)
(:mop-direct common-lisp:function :typeof clos:built-in-class)
(:mop-direct common-lisp:function :superclass common-lisp:t)
(:mop-direct clos:funcallable-standard-object :superclass common-lisp:function)
(:mop-direct clos:funcallable-standard-object :superclass common-lisp:standard-object)
(:mop-direct clos:generic-function :superclass clos:funcallable-standard-object)
(:mop-direct clos:funcallable-standard-object :package-name "CLOS")
(:mop-direct clos:funcallable-standard-object :precedance (common-lisp:function common-lisp:standard-object common-lisp:t))
(:mop-direct clos:funcallable-standard-object :classof clos:funcallable-standard-class)
(:mop-direct clos:funcallable-standard-object :typeof clos:funcallable-standard-class)
(:mop-direct clos:funcallable-standard-object :superclass common-lisp:function)
(:mop-direct clos:funcallable-standard-object :slot
 ((:name clos::$name) (:ordinal 1) (:readers (clos::funcallable-name)) (:writers ((common-lisp:setf clos::funcallable-name)))))
(:mop-direct clos:generic-function :superclass clos:metaobject)
(:mop-direct clos:generic-function :superclass clos:funcallable-standard-object)
(:mop-direct clos:standard-generic-function :superclass clos:generic-function)
(:mop-direct clos:generic-function :package-name "CLOS")
(:mop-direct clos:generic-function :precedance
 (clos:metaobject clos:funcallable-standard-object common-lisp:function common-lisp:standard-object common-lisp:t))
(:mop-direct clos:generic-function :classof clos:funcallable-standard-class)
(:mop-direct clos:generic-function :typeof clos:funcallable-standard-class)
(:mop-direct clos:generic-function :superclass clos:funcallable-standard-object)
(:mop-direct clos:generic-function :slot
 ((:name clos::$listeners) (:ordinal 1) (:type common-lisp:list) (:readers (clos::gf-listeners))
  (:writers ((common-lisp:setf clos::gf-listeners)))))
(:mop-direct clos:standard-generic-function :superclass clos:generic-function)
(:mop-direct closer-mop:standard-generic-function :superclass clos:standard-generic-function)
(:mop-direct clos:standard-generic-function :package-name "CLOS")
(:mop-direct clos:standard-generic-function :precedance
 (clos:generic-function clos:metaobject clos:funcallable-standard-object common-lisp:function common-lisp:standard-object common-lisp:t))
(:mop-direct clos:standard-generic-function :classof clos:funcallable-standard-class)
(:mop-direct clos:standard-generic-function :typeof clos:funcallable-standard-class)
(:mop-direct clos:standard-generic-function :superclass clos:generic-function)
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$signature) (:ordinal 1) (:type (common-lisp:simple-vector 6)) (:readers (clos::std-gf-signature))
  (:writers ((common-lisp:setf clos::std-gf-signature)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$argorder) (:ordinal 2) (:type common-lisp:list) (:readers (clos::std-gf-argorder))
  (:writers ((common-lisp:setf clos::std-gf-argorder)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$methods) (:ordinal 3) (:type common-lisp:list) (:readers (clos::std-gf-methods))
  (:writers ((common-lisp:setf clos::std-gf-methods)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$method-combination) (:ordinal 4) (:type clos:method-combination) (:readers (clos::std-gf-method-combination))
  (:writers ((common-lisp:setf clos::std-gf-method-combination)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$default-method-class) (:ordinal 5) (:type clos:class) (:readers (clos::std-gf-default-method-class))
  (:writers ((common-lisp:setf clos::std-gf-default-method-class)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$lambda-list) (:ordinal 6) (:type common-lisp:list) (:readers (clos::std-gf-lambda-list))
  (:writers ((common-lisp:setf clos::std-gf-lambda-list)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$documentation) (:ordinal 7) (:type (common-lisp:or common-lisp:null common-lisp:string)) (:readers (clos::std-gf-documentation))
  (:writers ((common-lisp:setf clos::std-gf-documentation)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$declspecs) (:ordinal 8) (:type common-lisp:list) (:readers (clos::std-gf-declspecs))
  (:writers ((common-lisp:setf clos::std-gf-declspecs)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$effective-method-cache) (:ordinal 9) (:type common-lisp:list) (:readers (clos::std-gf-effective-method-cache))
  (:writers ((common-lisp:setf clos::std-gf-effective-method-cache)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$initialized) (:ordinal 10) (:type common-lisp:boolean) (:readers (clos::std-gf-initialized))
  (:writers ((common-lisp:setf clos::std-gf-initialized)))))
(:mop-direct closer-mop:standard-generic-function :superclass clos:standard-generic-function)
(:mop-direct closer-mop:standard-generic-function :package-name "CLOSER-MOP")
(:mop-direct closer-mop:standard-generic-function :precedance
 (clos:standard-generic-function clos:generic-function clos:metaobject clos:funcallable-standard-object common-lisp:function
  common-lisp:standard-object common-lisp:t))
(:mop-direct closer-mop:standard-generic-function :classof clos:funcallable-standard-class)
(:mop-direct closer-mop:standard-generic-function :typeof clos:funcallable-standard-class)
(:mop-direct closer-mop:standard-generic-function :superclass clos:standard-generic-function)
(:mop-direct closer-mop:standard-generic-function :slot ((:name closer-mop::initial-methods) (:ordinal 1) (:initform 'common-lisp:nil)))
(:mop-direct closer-mop:standard-generic-function :prototype #<closer-mop:standard-generic-function #<unbound>>)
(:mop-direct clos:standard-generic-function :prototype #<clos:standard-generic-function #<unbound>>)
(:mop-direct clos:generic-function :prototype #<clos:generic-function #<unbound>>)
(:mop-direct clos:funcallable-standard-object :prototype #<clos:funcallable-standard-object #<unbound>>)
(:mop-direct common-lisp:function :prototype #<system-function common-lisp:cons>)
(:mop-direct common-lisp:character :superclass common-lisp:t)
(:mop-direct common-lisp:character :package-name "COMMON-LISP")
(:mop-direct common-lisp:character :classof clos:built-in-class)
(:mop-direct common-lisp:character :typeof clos:built-in-class)
(:mop-direct common-lisp:character :superclass common-lisp:t)
(:mop-direct common-lisp:character :prototype #\space)
(:mop-direct common-lisp:structure-object :superclass common-lisp:t)
(:mop-direct system::inspection :superclass common-lisp:structure-object)
(:mop-direct system::input-character :superclass common-lisp:structure-object)
(:mop-direct common-lisp:restart :superclass common-lisp:structure-object)
(:mop-direct clos:structure-stablehash :superclass common-lisp:structure-object)
(:mop-direct system::loop-initialization :superclass common-lisp:structure-object)
(:mop-direct system::c-source-point :superclass common-lisp:structure-object)
(:mop-direct system::anode :superclass common-lisp:structure-object)
(:mop-direct system::fnode :superclass common-lisp:structure-object)
(:mop-direct system::const :superclass common-lisp:structure-object)
(:mop-direct system::var :superclass common-lisp:structure-object)
(:mop-direct system::control-string-directive :superclass common-lisp:structure-object)
(:mop-direct ffi::ffi-module :superclass common-lisp:structure-object)
(:mop-direct i18n:locale-conv :superclass common-lisp:structure-object)
(:mop-direct posix:utmpx :superclass common-lisp:structure-object)
(:mop-direct posix:hostent :superclass common-lisp:structure-object)
(:mop-direct posix:user-info :superclass common-lisp:structure-object)
(:mop-direct posix:group-info :superclass common-lisp:structure-object)
(:mop-direct posix:file-stat :superclass common-lisp:structure-object)
(:mop-direct posix:stat-vfs :superclass common-lisp:structure-object)
(:mop-direct posix:uname :superclass common-lisp:structure-object)
(:mop-direct posix:rlimit :superclass common-lisp:structure-object)
(:mop-direct posix:usage :superclass common-lisp:structure-object)
(:mop-direct posix:file-info :superclass common-lisp:structure-object)
(:mop-direct posix:service :superclass common-lisp:structure-object)
(:mop-direct regexp:match :superclass common-lisp:structure-object)
(:mop-direct ql-gunzipper::sliding-window-stream :superclass common-lisp:structure-object)
(:mop-direct ql-gunzipper::bit-stream :superclass common-lisp:structure-object)
(:mop-direct ql-gunzipper::decode-tree :superclass common-lisp:structure-object)
(:mop-direct common-lisp:structure-object :package-name "COMMON-LISP")
(:mop-direct common-lisp:structure-object :classof clos:structure-class)
(:mop-direct common-lisp:structure-object :typeof clos:structure-class)
(:mop-direct common-lisp:structure-object :superclass common-lisp:t)
(:mop-direct system::inspection :superclass common-lisp:structure-object)
(:mop-direct system::inspection :package-name "SYSTEM")
(:mop-direct system::inspection :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct system::inspection :classof clos:structure-class)
(:mop-direct system::inspection :typeof clos:structure-class)
(:mop-direct system::inspection :superclass common-lisp:structure-object)
(:mop-direct system::inspection :slot
 ((:name system::self) (:ordinal 1) (:initargs (:self)) (:readers (system::insp-self)) (:writers ((common-lisp:setf system::insp-self)))))
(:mop-direct system::inspection :slot
 ((:name system::id) (:ordinal 2) (:initform (common-lisp:fill-pointer system::*inspect-all*)) (:type common-lisp:fixnum) (:initargs (:id))
  (:readers (system::insp-id)) (:writers ((common-lisp:setf system::insp-id)))))
(:mop-direct system::inspection :slot
 ((:name system::title) (:ordinal 3) (:initform "") (:type common-lisp:string) (:initargs (:title)) (:readers (system::insp-title))
  (:writers ((common-lisp:setf system::insp-title)))))
(:mop-direct system::inspection :slot
 ((:name system::blurb) (:ordinal 4) (:type common-lisp:list) (:initargs (:blurb)) (:readers (system::insp-blurb))
  (:writers ((common-lisp:setf system::insp-blurb)))))
(:mop-direct system::inspection :slot
 ((:name system::up) (:ordinal 5) (:type (common-lisp:or common-lisp:null system::inspection)) (:initargs (:up)) (:readers (system::insp-up))
  (:writers ((common-lisp:setf system::insp-up)))))
(:mop-direct system::inspection :slot
 ((:name system::num-slots) (:ordinal 6) (:initform 0) (:type common-lisp:fixnum) (:initargs (:num-slots)) (:readers (system::insp-num-slots))
  (:writers ((common-lisp:setf system::insp-num-slots)))))
(:mop-direct system::inspection :slot
 ((:name system::pos) (:ordinal 7) (:type (common-lisp:or common-lisp:null common-lisp:fixnum)) (:initargs (:pos)) (:readers (system::insp-pos))
  (:writers ((common-lisp:setf system::insp-pos)))))
(:mop-direct system::inspection :slot
 ((:name system::nth-slot) (:ordinal 8)
  (:type (common-lisp:or common-lisp:null (common-lisp:function (common-lisp:integer) (common-lisp:values common-lisp:t common-lisp:t))))
  (:initargs (:nth-slot)) (:readers (system::insp-nth-slot)) (:writers ((common-lisp:setf system::insp-nth-slot)))))
(:mop-direct system::inspection :slot
 ((:name system::set-slot) (:ordinal 9)
  (:type (common-lisp:or common-lisp:null (common-lisp:function (common-lisp:integer common-lisp:t) common-lisp:t))) (:initargs (:set-slot))
  (:readers (system::insp-set-slot)) (:writers ((common-lisp:setf system::insp-set-slot)))))
(:mop-direct system::inspection :prototype
 #S(system::inspection :self #<unbound> :id #<unbound> :title #<unbound> :blurb #<unbound> :up #<unbound> :num-slots #<unbound> :pos #<unbound>
    :nth-slot #<unbound> :set-slot #<unbound>))
(:mop-direct system::input-character :superclass common-lisp:structure-object)
(:mop-direct system::input-character :package-name "SYSTEM")
(:mop-direct system::input-character :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct system::input-character :classof clos:structure-class)
(:mop-direct system::input-character :typeof clos:structure-class)
(:mop-direct system::input-character :superclass common-lisp:structure-object)
(:mop-direct system::input-character :slot
 ((:name common-lisp:char) (:ordinal 1) (:type (common-lisp:or common-lisp:null common-lisp:character)) (:initargs (:char))
  (:readers (system::input-character-char)) (:writers ((common-lisp:setf system::input-character-char)))))
(:mop-direct system::input-character :slot
 ((:name system::bits) (:ordinal 2) (:initform 0) (:type (common-lisp:integer 0 15)) (:initargs (:bits))
  (:readers (system::input-character-bits)) (:writers ((common-lisp:setf system::input-character-bits)))))
(:mop-direct system::input-character :slot
 ((:name system::font) (:ordinal 3) (:initform 0) (:type (common-lisp:integer 0 15)) (:initargs (:font))
  (:readers (system::input-character-font)) (:writers ((common-lisp:setf system::input-character-font)))))
(:mop-direct system::input-character :slot
 ((:name system::key) (:ordinal 4) (:type (common-lisp:or common-lisp:null common-lisp:character common-lisp:symbol)) (:initargs (:key))
  (:readers (system::input-character-key)) (:writers ((common-lisp:setf system::input-character-key)))))
(:mop-direct system::input-character :prototype #S(system::input-character :char #<unbound> :bits #<unbound> :font #<unbound> :key #<unbound>))
(:mop-direct common-lisp:restart :superclass common-lisp:structure-object)
(:mop-direct common-lisp:restart :package-name "COMMON-LISP")
(:mop-direct common-lisp:restart :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct common-lisp:restart :classof clos:structure-class)
(:mop-direct common-lisp:restart :typeof clos:structure-class)
(:mop-direct common-lisp:restart :superclass common-lisp:structure-object)
(:mop-direct common-lisp:restart :slot
 ((:name system::name) (:ordinal 1) (:initargs (:name)) (:readers (common-lisp:restart-name))
  (:writers ((common-lisp:setf common-lisp:restart-name)))))
(:mop-direct common-lisp:restart :slot
 ((:name system::test) (:ordinal 2) (:initform #'system::default-restart-test) (:initargs (:test)) (:readers (system::restart-test))
  (:writers ((common-lisp:setf system::restart-test)))))
(:mop-direct common-lisp:restart :slot
 ((:name system::invoke-tag) (:ordinal 3) (:initargs (:invoke-tag)) (:readers (system::restart-invoke-tag))
  (:writers ((common-lisp:setf system::restart-invoke-tag)))))
(:mop-direct common-lisp:restart :slot
 ((:name system::invoke-function) (:ordinal 4) (:initargs (:invoke-function)) (:readers (system::restart-invoke-function))
  (:writers ((common-lisp:setf system::restart-invoke-function)))))
(:mop-direct common-lisp:restart :slot
 ((:name system::report) (:ordinal 5) (:initargs (:report)) (:readers (system::restart-report))
  (:writers ((common-lisp:setf system::restart-report)))))
(:mop-direct common-lisp:restart :slot
 ((:name system::interactive) (:ordinal 6) (:initform #'system::default-restart-interactive) (:initargs (:interactive))
  (:readers (system::restart-interactive)) (:writers ((common-lisp:setf system::restart-interactive)))))
(:mop-direct common-lisp:restart :slot
 ((:name system::meaningfulp) (:ordinal 7) (:initform common-lisp:t) (:initargs (:meaningfulp)) (:readers (system::restart-meaningfulp))
  (:writers ((common-lisp:setf system::restart-meaningfulp)))))
(:mop-direct common-lisp:restart :prototype
 #S(common-lisp:restart :name #<unbound> :test #<unbound> :invoke-tag #<unbound> :invoke-function #<unbound> :report #<unbound>
    :interactive #<unbound> :meaningfulp #<unbound>))
(:mop-direct clos:structure-stablehash :superclass common-lisp:structure-object)
(:mop-direct clos:structure-stablehash :package-name "CLOS")
(:mop-direct clos:structure-stablehash :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct clos:structure-stablehash :classof clos:structure-class)
(:mop-direct clos:structure-stablehash :typeof clos:structure-class)
(:mop-direct clos:structure-stablehash :superclass common-lisp:structure-object)
(:mop-direct clos:structure-stablehash :slot
 ((:name clos::hashcode) (:ordinal 1) (:initform (system::random-posfixnum)) (:initargs (:hashcode))
  (:readers (clos::structure-stablehash-hashcode)) (:writers ((common-lisp:setf clos::structure-stablehash-hashcode)))))
(:mop-direct clos:structure-stablehash :prototype #S(clos:structure-stablehash :hashcode #<unbound>))
(:mop-direct system::loop-initialization :superclass common-lisp:structure-object)
(:mop-direct system::loop-initialization :package-name "SYSTEM")
(:mop-direct system::loop-initialization :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct system::loop-initialization :classof clos:structure-class)
(:mop-direct system::loop-initialization :typeof clos:structure-class)
(:mop-direct system::loop-initialization :superclass common-lisp:structure-object)
(:mop-direct system::loop-initialization :slot
 ((:name system::specform) (:ordinal 1) (:initargs (:specform)) (:readers (system::li-specform))
  (:writers ((common-lisp:setf system::li-specform)))))
(:mop-direct system::loop-initialization :slot
 ((:name system::bindings) (:ordinal 2) (:initargs (:bindings)) (:readers (system::li-bindings))
  (:writers ((common-lisp:setf system::li-bindings)))))
(:mop-direct system::loop-initialization :slot
 ((:name system::declspecs) (:ordinal 3) (:initargs (:declspecs)) (:readers (system::li-declspecs))
  (:writers ((common-lisp:setf system::li-declspecs)))))
(:mop-direct system::loop-initialization :slot
 ((:name system::endtest-forms) (:ordinal 4) (:initargs (:endtest-forms)) (:readers (system::li-endtest-forms))
  (:writers ((common-lisp:setf system::li-endtest-forms)))))
(:mop-direct system::loop-initialization :slot
 ((:name system::everytime) (:ordinal 5) (:initargs (:everytime)) (:readers (system::li-everytime))
  (:writers ((common-lisp:setf system::li-everytime)))))
(:mop-direct system::loop-initialization :slot
 ((:name system::requires-stepbefore) (:ordinal 6) (:initargs (:requires-stepbefore)) (:readers (system::li-requires-stepbefore))
  (:writers ((common-lisp:setf system::li-requires-stepbefore)))))
(:mop-direct system::loop-initialization :slot
 ((:name system::depends-preceding) (:ordinal 7) (:initargs (:depends-preceding)) (:readers (system::li-depends-preceding))
  (:writers ((common-lisp:setf system::li-depends-preceding)))))
(:mop-direct system::loop-initialization :slot
 ((:name system::preamble) (:ordinal 8) (:initargs (:preamble)) (:readers (system::li-preamble))
  (:writers ((common-lisp:setf system::li-preamble)))))
(:mop-direct system::loop-initialization :slot
 ((:name system::later-depend) (:ordinal 9) (:initargs (:later-depend)) (:readers (system::li-later-depend))
  (:writers ((common-lisp:setf system::li-later-depend)))))
(:mop-direct system::loop-initialization :prototype
 #S(system::loop-initialization :specform #<unbound> :bindings #<unbound> :declspecs #<unbound> :endtest-forms #<unbound> :everytime #<unbound>
    :requires-stepbefore #<unbound> :depends-preceding #<unbound> :preamble #<unbound> :later-depend #<unbound>))
(:mop-direct system::c-source-point :superclass common-lisp:structure-object)
(:mop-direct system::c-source-point :package-name "SYSTEM")
(:mop-direct system::c-source-point :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct system::c-source-point :classof clos:structure-class)
(:mop-direct system::c-source-point :typeof clos:structure-class)
(:mop-direct system::c-source-point :superclass common-lisp:structure-object)
(:mop-direct system::c-source-point :slot
 ((:name system::lineno1) (:ordinal 1) (:initform system::*compile-file-lineno1*) (:initargs (:lineno1))
  (:readers (system::c-source-point-lineno1)) (:writers ((common-lisp:setf system::c-source-point-lineno1)))))
(:mop-direct system::c-source-point :slot
 ((:name system::lineno2) (:ordinal 2) (:initform system::*compile-file-lineno2*) (:initargs (:lineno2))
  (:readers (system::c-source-point-lineno2)) (:writers ((common-lisp:setf system::c-source-point-lineno2)))))
(:mop-direct system::c-source-point :slot
 ((:name system::file) (:ordinal 3) (:initform common-lisp:*compile-file-truename*) (:initargs (:file)) (:readers (system::c-source-point-file))
  (:writers ((common-lisp:setf system::c-source-point-file)))))
(:mop-direct system::c-source-point :prototype #S(system::c-source-point :lineno1 #<unbound> :lineno2 #<unbound> :file #<unbound>))
(:mop-direct system::anode :superclass common-lisp:structure-object)
(:mop-direct system::anode :package-name "SYSTEM")
(:mop-direct system::anode :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct system::anode :classof clos:structure-class)
(:mop-direct system::anode :typeof clos:structure-class)
(:mop-direct system::anode :superclass common-lisp:structure-object)
(:mop-direct system::anode :slot
 ((:name common-lisp:type) (:ordinal 1) (:initargs (:type)) (:readers (system::anode-type)) (:writers ((common-lisp:setf system::anode-type)))))
(:mop-direct system::anode :slot
 ((:name system::seclass) (:ordinal 2) (:initargs (:seclass)) (:readers (system::anode-seclass))
  (:writers ((common-lisp:setf system::anode-seclass)))))
(:mop-direct system::anode :slot
 ((:name system::code) (:ordinal 3) (:initargs (:code)) (:readers (system::anode-code)) (:writers ((common-lisp:setf system::anode-code)))))
(:mop-direct system::anode :prototype #<system::anode :type #<unbound> :seclass #<unbound> :code #<unbound>>)
(:mop-direct system::fnode :superclass common-lisp:structure-object)
(:mop-direct system::fnode :package-name "SYSTEM")
(:mop-direct system::fnode :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct system::fnode :classof clos:structure-class)
(:mop-direct system::fnode :typeof clos:structure-class)
(:mop-direct system::fnode :superclass common-lisp:structure-object)
(:mop-direct system::fnode :slot
 ((:name system::name) (:ordinal 1) (:initargs (:name)) (:readers (system::fnode-name)) (:writers ((common-lisp:setf system::fnode-name)))))
(:mop-direct system::fnode :slot
 ((:name system::code) (:ordinal 2) (:initargs (:code)) (:readers (system::fnode-code)) (:writers ((common-lisp:setf system::fnode-code)))))
(:mop-direct system::fnode :slot
 ((:name system::enclosing) (:ordinal 3) (:initargs (:enclosing)) (:readers (system::fnode-enclosing))
  (:writers ((common-lisp:setf system::fnode-enclosing)))))
(:mop-direct system::fnode :slot
 ((:name system::venvconst) (:ordinal 4) (:initargs (:venvconst)) (:readers (system::fnode-venvconst))
  (:writers ((common-lisp:setf system::fnode-venvconst)))))
(:mop-direct system::fnode :slot
 ((:name system::venvc) (:ordinal 5) (:initargs (:venvc)) (:readers (system::fnode-venvc)) (:writers ((common-lisp:setf system::fnode-venvc)))))
(:mop-direct system::fnode :slot
 ((:name system::blocks-offset) (:ordinal 6) (:initargs (:blocks-offset)) (:readers (system::fnode-blocks-offset))
  (:writers ((common-lisp:setf system::fnode-blocks-offset)))))
(:mop-direct system::fnode :slot
 ((:name system::blocks) (:ordinal 7) (:initargs (:blocks)) (:readers (system::fnode-blocks))
  (:writers ((common-lisp:setf system::fnode-blocks)))))
(:mop-direct system::fnode :slot
 ((:name system::tagbodys-offset) (:ordinal 8) (:initargs (:tagbodys-offset)) (:readers (system::fnode-tagbodys-offset))
  (:writers ((common-lisp:setf system::fnode-tagbodys-offset)))))
(:mop-direct system::fnode :slot
 ((:name system::tags) (:ordinal 9) (:initargs (:tags)) (:readers (system::fnode-tags)) (:writers ((common-lisp:setf system::fnode-tags)))))
(:mop-direct system::fnode :slot
 ((:name system::tagbodys) (:ordinal 10) (:initargs (:tagbodys)) (:readers (system::fnode-tagbodys))
  (:writers ((common-lisp:setf system::fnode-tagbodys)))))
(:mop-direct system::fnode :slot
 ((:name system::keyword-offset) (:ordinal 11) (:initargs (:keyword-offset)) (:readers (system::fnode-keyword-offset))
  (:writers ((common-lisp:setf system::fnode-keyword-offset)))))
(:mop-direct system::fnode :slot
 ((:name system::req-num) (:ordinal 12) (:initform 0) (:initargs (:req-num)) (:readers (system::fnode-req-num))
  (:writers ((common-lisp:setf system::fnode-req-num)))))
(:mop-direct system::fnode :slot
 ((:name system::opt-num) (:ordinal 13) (:initform 0) (:initargs (:opt-num)) (:readers (system::fnode-opt-num))
  (:writers ((common-lisp:setf system::fnode-opt-num)))))
(:mop-direct system::fnode :slot
 ((:name system::rest-flag) (:ordinal 14) (:initargs (:rest-flag)) (:readers (system::fnode-rest-flag))
  (:writers ((common-lisp:setf system::fnode-rest-flag)))))
(:mop-direct system::fnode :slot
 ((:name system::keyword-flag) (:ordinal 15) (:initargs (:keyword-flag)) (:readers (system::fnode-keyword-flag))
  (:writers ((common-lisp:setf system::fnode-keyword-flag)))))
(:mop-direct system::fnode :slot
 ((:name system::keywords) (:ordinal 16) (:initargs (:keywords)) (:readers (system::fnode-keywords))
  (:writers ((common-lisp:setf system::fnode-keywords)))))
(:mop-direct system::fnode :slot
 ((:name system::allow-other-keys-flag) (:ordinal 17) (:initargs (:allow-other-keys-flag)) (:readers (system::fnode-allow-other-keys-flag))
  (:writers ((common-lisp:setf system::fnode-allow-other-keys-flag)))))
(:mop-direct system::fnode :slot
 ((:name system::lambda-list) (:ordinal 18) (:initargs (:lambda-list)) (:readers (system::fnode-lambda-list))
  (:writers ((common-lisp:setf system::fnode-lambda-list)))))
(:mop-direct system::fnode :slot
 ((:name clos:documentation) (:ordinal 19) (:initargs (:documentation)) (:readers (system::fnode-documentation))
  (:writers ((common-lisp:setf system::fnode-documentation)))))
(:mop-direct system::fnode :slot
 ((:name system::denv) (:ordinal 20) (:initform system::*denv*) (:initargs (:denv)) (:readers (system::fnode-denv))
  (:writers ((common-lisp:setf system::fnode-denv)))))
(:mop-direct system::fnode :slot
 ((:name system::consts-offset) (:ordinal 21) (:initargs (:consts-offset)) (:readers (system::fnode-consts-offset))
  (:writers ((common-lisp:setf system::fnode-consts-offset)))))
(:mop-direct system::fnode :slot
 ((:name system::consts) (:ordinal 22) (:initargs (:consts)) (:readers (system::fnode-consts))
  (:writers ((common-lisp:setf system::fnode-consts)))))
(:mop-direct system::fnode :slot
 ((:name system::consts-forms) (:ordinal 23) (:initargs (:consts-forms)) (:readers (system::fnode-consts-forms))
  (:writers ((common-lisp:setf system::fnode-consts-forms)))))
(:mop-direct system::fnode :slot
 ((:name system::consts-ltv-forms) (:ordinal 24) (:initargs (:consts-ltv-forms)) (:readers (system::fnode-consts-ltv-forms))
  (:writers ((common-lisp:setf system::fnode-consts-ltv-forms)))))
(:mop-direct system::fnode :slot
 ((:name system::gf-p) (:ordinal 25) (:initargs (:gf-p)) (:readers (system::fnode-gf-p)) (:writers ((common-lisp:setf system::fnode-gf-p)))))
(:mop-direct system::fnode :slot
 ((:name system::far-used-vars) (:ordinal 26) (:initargs (:far-used-vars)) (:readers (system::fnode-far-used-vars))
  (:writers ((common-lisp:setf system::fnode-far-used-vars)))))
(:mop-direct system::fnode :slot
 ((:name system::far-assigned-vars) (:ordinal 27) (:initargs (:far-assigned-vars)) (:readers (system::fnode-far-assigned-vars))
  (:writers ((common-lisp:setf system::fnode-far-assigned-vars)))))
(:mop-direct system::fnode :slot
 ((:name system::far-used-blocks) (:ordinal 28) (:initargs (:far-used-blocks)) (:readers (system::fnode-far-used-blocks))
  (:writers ((common-lisp:setf system::fnode-far-used-blocks)))))
(:mop-direct system::fnode :slot
 ((:name system::far-used-tagbodys) (:ordinal 29) (:initargs (:far-used-tagbodys)) (:readers (system::fnode-far-used-tagbodys))
  (:writers ((common-lisp:setf system::fnode-far-used-tagbodys)))))
(:mop-direct system::fnode :slot
 ((:name common-lisp:ignore) (:ordinal 30) (:initargs (:ignore)) (:readers (system::fnode-ignore))
  (:writers ((common-lisp:setf system::fnode-ignore)))))
(:mop-direct system::fnode :slot
 ((:name common-lisp:ignorable) (:ordinal 31) (:initargs (:ignorable)) (:readers (system::fnode-ignorable))
  (:writers ((common-lisp:setf system::fnode-ignorable)))))
(:mop-direct system::fnode :slot
 ((:name system::used) (:ordinal 32) (:initargs (:used)) (:readers (system::fnode-used)) (:writers ((common-lisp:setf system::fnode-used)))))
(:mop-direct system::fnode :prototype
 #S(system::fnode :name #<unbound> :code #<unbound> :enclosing #<unbound> :venvconst #<unbound> :venvc #<unbound> :blocks-offset #<unbound>
    :blocks #<unbound> :tagbodys-offset #<unbound> :tags #<unbound> :tagbodys #<unbound> :keyword-offset #<unbound> :req-num #<unbound>
    :opt-num #<unbound> :rest-flag #<unbound> :keyword-flag #<unbound> :keywords #<unbound> :allow-other-keys-flag #<unbound>
    :lambda-list #<unbound> :documentation #<unbound> :denv #<unbound> :consts-offset #<unbound> :consts #<unbound> :consts-forms #<unbound>
    :consts-ltv-forms #<unbound> :gf-p #<unbound> :far-used-vars #<unbound> :far-assigned-vars #<unbound> :far-used-blocks #<unbound>
    :far-used-tagbodys #<unbound> :ignore #<unbound> :ignorable #<unbound> :used #<unbound>))
(:mop-direct system::const :superclass common-lisp:structure-object)
(:mop-direct system::const :package-name "SYSTEM")
(:mop-direct system::const :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct system::const :classof clos:structure-class)
(:mop-direct system::const :typeof clos:structure-class)
(:mop-direct system::const :superclass common-lisp:structure-object)
(:mop-direct system::const :slot
 ((:name system::value) (:ordinal 1) (:initargs (:value)) (:readers (system::const-value)) (:writers ((common-lisp:setf system::const-value)))))
(:mop-direct system::const :slot
 ((:name system::form) (:ordinal 2) (:initargs (:form)) (:readers (system::const-form)) (:writers ((common-lisp:setf system::const-form)))))
(:mop-direct system::const :slot
 ((:name system::ltv-form) (:ordinal 3) (:initargs (:ltv-form)) (:readers (system::const-ltv-form))
  (:writers ((common-lisp:setf system::const-ltv-form)))))
(:mop-direct system::const :slot
 ((:name system::horizon) (:ordinal 4) (:initargs (:horizon)) (:readers (system::const-horizon))
  (:writers ((common-lisp:setf system::const-horizon)))))
(:mop-direct system::const :prototype #S(system::const :value #<unbound> :form #<unbound> :ltv-form #<unbound> :horizon #<unbound>))
(:mop-direct system::var :superclass common-lisp:structure-object)
(:mop-direct system::var :package-name "SYSTEM")
(:mop-direct system::var :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct system::var :classof clos:structure-class)
(:mop-direct system::var :typeof clos:structure-class)
(:mop-direct system::var :superclass common-lisp:structure-object)
(:mop-direct system::var :slot ((:name system::name) (:ordinal 1) (:initargs (:name)) (:readers (system::var-name))))
(:mop-direct system::var :slot ((:name system::specialp) (:ordinal 2) (:initargs (:specialp)) (:readers (system::var-specialp))))
(:mop-direct system::var :slot
 ((:name common-lisp:constantp) (:ordinal 3) (:initargs (:constantp)) (:readers (system::var-constantp))
  (:writers ((common-lisp:setf system::var-constantp)))))
(:mop-direct system::var :slot
 ((:name system::constant) (:ordinal 4) (:initargs (:constant)) (:readers (system::var-constant))
  (:writers ((common-lisp:setf system::var-constant)))))
(:mop-direct system::var :slot
 ((:name system::usedp) (:ordinal 5) (:initargs (:usedp)) (:readers (system::var-usedp)) (:writers ((common-lisp:setf system::var-usedp)))))
(:mop-direct system::var :slot
 ((:name system::for-value-usedp) (:ordinal 6) (:initargs (:for-value-usedp)) (:readers (system::var-for-value-usedp))
  (:writers ((common-lisp:setf system::var-for-value-usedp)))))
(:mop-direct system::var :slot
 ((:name system::really-usedp) (:ordinal 7) (:initargs (:really-usedp)) (:readers (system::var-really-usedp))
  (:writers ((common-lisp:setf system::var-really-usedp)))))
(:mop-direct system::var :slot
 ((:name system::assignedp) (:ordinal 8) (:initargs (:assignedp)) (:readers (system::var-assignedp))
  (:writers ((common-lisp:setf system::var-assignedp)))))
(:mop-direct system::var :slot
 ((:name system::modified-list) (:ordinal 9) (:initform 'common-lisp:nil) (:initargs (:modified-list)) (:readers (system::var-modified-list))
  (:writers ((common-lisp:setf system::var-modified-list)))))
(:mop-direct system::var :slot
 ((:name system::replaceable-list) (:ordinal 10) (:initform 'common-lisp:nil) (:initargs (:replaceable-list))
  (:readers (system::var-replaceable-list)) (:writers ((common-lisp:setf system::var-replaceable-list)))))
(:mop-direct system::var :slot
 ((:name system::closurep) (:ordinal 11) (:initargs (:closurep)) (:readers (system::var-closurep))
  (:writers ((common-lisp:setf system::var-closurep)))))
(:mop-direct system::var :slot ((:name system::stackz) (:ordinal 12) (:initargs (:stackz)) (:readers (system::var-stackz))))
(:mop-direct system::var :slot ((:name system::venvc) (:ordinal 13) (:initargs (:venvc)) (:readers (system::var-venvc))))
(:mop-direct system::var :slot ((:name system::fnode) (:ordinal 14) (:initargs (:fnode)) (:readers (system::var-fnode))))
(:mop-direct system::var :prototype
 #S(system::var :name #<unbound> :specialp #<unbound> :constantp #<unbound> :constant #<unbound> :usedp #<unbound> :for-value-usedp #<unbound>
    :really-usedp #<unbound> :assignedp #<unbound> :modified-list #<unbound> :replaceable-list #<unbound> :closurep #<unbound>
    :stackz #<unbound> :venvc #<unbound> :fnode #<unbound>))
(:mop-direct system::control-string-directive :superclass common-lisp:structure-object)
(:mop-direct system::control-string-directive :package-name "SYSTEM")
(:mop-direct system::control-string-directive :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct system::control-string-directive :classof clos:structure-class)
(:mop-direct system::control-string-directive :typeof clos:structure-class)
(:mop-direct system::control-string-directive :superclass common-lisp:structure-object)
(:mop-direct system::control-string-directive :slot
 ((:name common-lisp:type) (:ordinal 1) (:initform 0) (:type common-lisp:fixnum) (:initargs (:type)) (:readers (system::csd-type))
  (:writers ((common-lisp:setf system::csd-type)))))
(:mop-direct system::control-string-directive :slot
 ((:name system::cs-index) (:ordinal 2) (:initform 0) (:type common-lisp:fixnum) (:initargs (:cs-index)) (:readers (system::csd-cs-index))
  (:writers ((common-lisp:setf system::csd-cs-index)))))
(:mop-direct system::control-string-directive :slot
 ((:name system::parm-list) (:ordinal 3) (:type common-lisp:list) (:initargs (:parm-list)) (:readers (system::csd-parm-list))
  (:writers ((common-lisp:setf system::csd-parm-list)))))
(:mop-direct system::control-string-directive :slot
 ((:name system::v-or-#-p) (:ordinal 4) (:type common-lisp:symbol) (:initargs (:v-or-#-p)) (:readers (system::csd-v-or-#-p))
  (:writers ((common-lisp:setf system::csd-v-or-#-p)))))
(:mop-direct system::control-string-directive :slot
 ((:name system::colon-p) (:ordinal 5) (:type common-lisp:symbol) (:initargs (:colon-p)) (:readers (system::csd-colon-p))
  (:writers ((common-lisp:setf system::csd-colon-p)))))
(:mop-direct system::control-string-directive :slot
 ((:name system::atsign-p) (:ordinal 6) (:type common-lisp:symbol) (:initargs (:atsign-p)) (:readers (system::csd-atsign-p))
  (:writers ((common-lisp:setf system::csd-atsign-p)))))
(:mop-direct system::control-string-directive :slot
 ((:name system::data) (:ordinal 7) (:initargs (:data)) (:readers (system::csd-data)) (:writers ((common-lisp:setf system::csd-data)))))
(:mop-direct system::control-string-directive :slot
 ((:name system::clause-chain) (:ordinal 8) (:initargs (:clause-chain)) (:readers (system::csd-clause-chain))
  (:writers ((common-lisp:setf system::csd-clause-chain)))))
(:mop-direct system::control-string-directive :prototype
 #<system::control-string-directive :type #<unbound> :cs-index #<unbound> :parm-list #<unbound> :v-or-#-p #<unbound> :colon-p #<unbound>
   :atsign-p #<unbound> :data #<unbound> :clause-chain #<unbound>>)
(:mop-direct ffi::ffi-module :superclass common-lisp:structure-object)
(:mop-direct ffi::ffi-module :package-name "FFI")
(:mop-direct ffi::ffi-module :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct ffi::ffi-module :classof clos:structure-class)
(:mop-direct ffi::ffi-module :typeof clos:structure-class)
(:mop-direct ffi::ffi-module :superclass common-lisp:structure-object)
(:mop-direct ffi::ffi-module :slot
 ((:name ffi::name) (:ordinal 1) (:initargs (:name)) (:readers (ffi::ffi-module-name)) (:writers ((common-lisp:setf ffi::ffi-module-name)))))
(:mop-direct ffi::ffi-module :slot
 ((:name ffi::c-name) (:ordinal 2) (:initargs (:c-name)) (:readers (ffi::ffi-module-c-name))
  (:writers ((common-lisp:setf ffi::ffi-module-c-name)))))
(:mop-direct ffi::ffi-module :slot
 ((:name ffi::object-table) (:ordinal 3)
  (:initform
   (common-lisp:make-hash-table :key-type '(common-lisp:or common-lisp:string common-lisp:symbol) :value-type
    '(common-lisp:cons common-lisp:string common-lisp:fixnum) :test 'ext:stablehash-equal :warn-if-needs-rehash-after-gc common-lisp:t))
  (:initargs (:object-table)) (:readers (ffi::ffi-module-object-table)) (:writers ((common-lisp:setf ffi::ffi-module-object-table)))))
(:mop-direct ffi::ffi-module :slot
 ((:name ffi::type-table) (:ordinal 4)
  (:initform
   (common-lisp:make-hash-table :key-type 'common-lisp:symbol :value-type '(common-lisp:or common-lisp:null common-lisp:string) :test
    'ext:stablehash-eq :warn-if-needs-rehash-after-gc common-lisp:t))
  (:initargs (:type-table)) (:readers (ffi::ffi-module-type-table)) (:writers ((common-lisp:setf ffi::ffi-module-type-table)))))
(:mop-direct ffi::ffi-module :slot
 ((:name ffi::init-once) (:ordinal 5) (:initform 'common-lisp:nil) (:initargs (:init-once)) (:readers (ffi::ffi-module-init-once))
  (:writers ((common-lisp:setf ffi::ffi-module-init-once)))))
(:mop-direct ffi::ffi-module :slot
 ((:name ffi::init-always) (:ordinal 6) (:initform 'common-lisp:nil) (:initargs (:init-always)) (:readers (ffi::ffi-module-init-always))
  (:writers ((common-lisp:setf ffi::ffi-module-init-always)))))
(:mop-direct ffi::ffi-module :slot
 ((:name ffi::fini) (:ordinal 7) (:initform 'common-lisp:nil) (:initargs (:fini)) (:readers (ffi::ffi-module-fini))
  (:writers ((common-lisp:setf ffi::ffi-module-fini)))))
(:mop-direct ffi::ffi-module :slot
 ((:name ffi::constant-table) (:ordinal 8)
  (:initform
   (common-lisp:make-hash-table :test 'ext:stablehash-eq :key-type 'common-lisp:symbol :value-type
    '(common-lisp:cons common-lisp:string common-lisp:vector) :warn-if-needs-rehash-after-gc common-lisp:t))
  (:initargs (:constant-table)) (:readers (ffi::ffi-module-constant-table)) (:writers ((common-lisp:setf ffi::ffi-module-constant-table)))))
(:mop-direct ffi::ffi-module :slot
 ((:name ffi::variable-list) (:ordinal 9) (:initform 'common-lisp:nil) (:initargs (:variable-list)) (:readers (ffi::ffi-module-variable-list))
  (:writers ((common-lisp:setf ffi::ffi-module-variable-list)))))
(:mop-direct ffi::ffi-module :slot
 ((:name ffi::function-list) (:ordinal 10) (:initform 'common-lisp:nil) (:initargs (:function-list)) (:readers (ffi::ffi-module-function-list))
  (:writers ((common-lisp:setf ffi::ffi-module-function-list)))))
(:mop-direct ffi::ffi-module :prototype
 #S(ffi::ffi-module :name #<unbound> :c-name #<unbound> :object-table #<unbound> :type-table #<unbound> :init-once #<unbound>
    :init-always #<unbound> :fini #<unbound> :constant-table #<unbound> :variable-list #<unbound> :function-list #<unbound>))
(:mop-direct i18n:locale-conv :superclass common-lisp:structure-object)
(:mop-direct i18n:locale-conv :package-name "I18N")
(:mop-direct i18n:locale-conv :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct i18n:locale-conv :classof clos:structure-class)
(:mop-direct i18n:locale-conv :typeof clos:structure-class)
(:mop-direct i18n:locale-conv :superclass common-lisp:structure-object)
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::decimal_point) (:ordinal 1) (:initargs (:decimal_point)) (:readers (i18n:locale-conv-decimal_point))
  (:writers ((common-lisp:setf i18n:locale-conv-decimal_point)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::thousands_sep) (:ordinal 2) (:initargs (:thousands_sep)) (:readers (i18n:locale-conv-thousands_sep))
  (:writers ((common-lisp:setf i18n:locale-conv-thousands_sep)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::grouping) (:ordinal 3) (:initargs (:grouping)) (:readers (i18n:locale-conv-grouping))
  (:writers ((common-lisp:setf i18n:locale-conv-grouping)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::int_curr_symbol) (:ordinal 4) (:initargs (:int_curr_symbol)) (:readers (i18n:locale-conv-int_curr_symbol))
  (:writers ((common-lisp:setf i18n:locale-conv-int_curr_symbol)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::currency_symbol) (:ordinal 5) (:initargs (:currency_symbol)) (:readers (i18n:locale-conv-currency_symbol))
  (:writers ((common-lisp:setf i18n:locale-conv-currency_symbol)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::mon_decimal_point) (:ordinal 6) (:initargs (:mon_decimal_point)) (:readers (i18n:locale-conv-mon_decimal_point))
  (:writers ((common-lisp:setf i18n:locale-conv-mon_decimal_point)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::mon_thousands_sep) (:ordinal 7) (:initargs (:mon_thousands_sep)) (:readers (i18n:locale-conv-mon_thousands_sep))
  (:writers ((common-lisp:setf i18n:locale-conv-mon_thousands_sep)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::mon_grouping) (:ordinal 8) (:initargs (:mon_grouping)) (:readers (i18n:locale-conv-mon_grouping))
  (:writers ((common-lisp:setf i18n:locale-conv-mon_grouping)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::positive_sign) (:ordinal 9) (:initargs (:positive_sign)) (:readers (i18n:locale-conv-positive_sign))
  (:writers ((common-lisp:setf i18n:locale-conv-positive_sign)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::negative_sign) (:ordinal 10) (:initargs (:negative_sign)) (:readers (i18n:locale-conv-negative_sign))
  (:writers ((common-lisp:setf i18n:locale-conv-negative_sign)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::int_frac_digits) (:ordinal 11) (:initargs (:int_frac_digits)) (:readers (i18n:locale-conv-int_frac_digits))
  (:writers ((common-lisp:setf i18n:locale-conv-int_frac_digits)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::frac_digits) (:ordinal 12) (:initargs (:frac_digits)) (:readers (i18n:locale-conv-frac_digits))
  (:writers ((common-lisp:setf i18n:locale-conv-frac_digits)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::p_cs_precedes) (:ordinal 13) (:initargs (:p_cs_precedes)) (:readers (i18n:locale-conv-p_cs_precedes))
  (:writers ((common-lisp:setf i18n:locale-conv-p_cs_precedes)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::p_sep_by_space) (:ordinal 14) (:initargs (:p_sep_by_space)) (:readers (i18n:locale-conv-p_sep_by_space))
  (:writers ((common-lisp:setf i18n:locale-conv-p_sep_by_space)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::n_cs_precedes) (:ordinal 15) (:initargs (:n_cs_precedes)) (:readers (i18n:locale-conv-n_cs_precedes))
  (:writers ((common-lisp:setf i18n:locale-conv-n_cs_precedes)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::n_sep_by_space) (:ordinal 16) (:initargs (:n_sep_by_space)) (:readers (i18n:locale-conv-n_sep_by_space))
  (:writers ((common-lisp:setf i18n:locale-conv-n_sep_by_space)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::p_sign_posn) (:ordinal 17) (:initargs (:p_sign_posn)) (:readers (i18n:locale-conv-p_sign_posn))
  (:writers ((common-lisp:setf i18n:locale-conv-p_sign_posn)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::n_sign_posn) (:ordinal 18) (:initargs (:n_sign_posn)) (:readers (i18n:locale-conv-n_sign_posn))
  (:writers ((common-lisp:setf i18n:locale-conv-n_sign_posn)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::int_p_cs_precedes) (:ordinal 19) (:initargs (:int_p_cs_precedes)) (:readers (i18n:locale-conv-int_p_cs_precedes))
  (:writers ((common-lisp:setf i18n:locale-conv-int_p_cs_precedes)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::int_n_cs_precedes) (:ordinal 20) (:initargs (:int_n_cs_precedes)) (:readers (i18n:locale-conv-int_n_cs_precedes))
  (:writers ((common-lisp:setf i18n:locale-conv-int_n_cs_precedes)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::int_p_sep_by_space) (:ordinal 21) (:initargs (:int_p_sep_by_space)) (:readers (i18n:locale-conv-int_p_sep_by_space))
  (:writers ((common-lisp:setf i18n:locale-conv-int_p_sep_by_space)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::int_n_sep_by_space) (:ordinal 22) (:initargs (:int_n_sep_by_space)) (:readers (i18n:locale-conv-int_n_sep_by_space))
  (:writers ((common-lisp:setf i18n:locale-conv-int_n_sep_by_space)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::int_p_sign_posn) (:ordinal 23) (:initargs (:int_p_sign_posn)) (:readers (i18n:locale-conv-int_p_sign_posn))
  (:writers ((common-lisp:setf i18n:locale-conv-int_p_sign_posn)))))
(:mop-direct i18n:locale-conv :slot
 ((:name i18n::int_n_sign_posn) (:ordinal 24) (:initargs (:int_n_sign_posn)) (:readers (i18n:locale-conv-int_n_sign_posn))
  (:writers ((common-lisp:setf i18n:locale-conv-int_n_sign_posn)))))
(:mop-direct i18n:locale-conv :prototype
 #<i18n:locale-conv :decimal_point #<unbound> :thousands_sep #<unbound> :grouping #<unbound> :int_curr_symbol #<unbound>
   :currency_symbol #<unbound> :mon_decimal_point #<unbound> :mon_thousands_sep #<unbound> :mon_grouping #<unbound> :positive_sign #<unbound>
   :negative_sign #<unbound> :int_frac_digits #<unbound> :frac_digits #<unbound> :p_cs_precedes #<unbound> :p_sep_by_space #<unbound>
   :n_cs_precedes #<unbound> :n_sep_by_space #<unbound> :p_sign_posn #<unbound> :n_sign_posn #<unbound> :int_p_cs_precedes #<unbound>
   :int_n_cs_precedes #<unbound> :int_p_sep_by_space #<unbound> :int_n_sep_by_space #<unbound> :int_p_sign_posn #<unbound>
   :int_n_sign_posn #<unbound>>)
(:mop-direct posix:utmpx :superclass common-lisp:structure-object)
(:mop-direct posix:utmpx :package-name "POSIX")
(:mop-direct posix:utmpx :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct posix:utmpx :classof clos:structure-class)
(:mop-direct posix:utmpx :typeof clos:structure-class)
(:mop-direct posix:utmpx :superclass common-lisp:structure-object)
(:mop-direct posix:utmpx :slot
 ((:name common-lisp:type) (:ordinal 1) (:initargs (:type)) (:readers (posix:utmpx-type)) (:writers ((common-lisp:setf posix:utmpx-type)))))
(:mop-direct posix:utmpx :slot
 ((:name posix::user) (:ordinal 2) (:initargs (:user)) (:readers (posix:utmpx-user)) (:writers ((common-lisp:setf posix:utmpx-user)))))
(:mop-direct posix:utmpx :slot
 ((:name posix::id) (:ordinal 3) (:initargs (:id)) (:readers (posix:utmpx-id)) (:writers ((common-lisp:setf posix:utmpx-id)))))
(:mop-direct posix:utmpx :slot
 ((:name posix::line) (:ordinal 4) (:initargs (:line)) (:readers (posix:utmpx-line)) (:writers ((common-lisp:setf posix:utmpx-line)))))
(:mop-direct posix:utmpx :slot
 ((:name posix::pid) (:ordinal 5) (:initargs (:pid)) (:readers (posix:utmpx-pid)) (:writers ((common-lisp:setf posix:utmpx-pid)))))
(:mop-direct posix:utmpx :slot
 ((:name posix::host) (:ordinal 6) (:initargs (:host)) (:readers (posix:utmpx-host)) (:writers ((common-lisp:setf posix:utmpx-host)))))
(:mop-direct posix:utmpx :slot
 ((:name posix::tv) (:ordinal 7) (:initargs (:tv)) (:readers (posix:utmpx-tv)) (:writers ((common-lisp:setf posix:utmpx-tv)))))
(:mop-direct posix:utmpx :prototype
 #<posix:utmpx :type #<unbound> :user #<unbound> :id #<unbound> :line #<unbound> :pid #<unbound> :host #<unbound> :tv #<unbound>>)
(:mop-direct posix:hostent :superclass common-lisp:structure-object)
(:mop-direct posix:hostent :package-name "POSIX")
(:mop-direct posix:hostent :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct posix:hostent :classof clos:structure-class)
(:mop-direct posix:hostent :typeof clos:structure-class)
(:mop-direct posix:hostent :superclass common-lisp:structure-object)
(:mop-direct posix:hostent :slot
 ((:name posix::name) (:ordinal 1) (:initform "") (:type common-lisp:simple-string) (:initargs (:name)) (:readers (posix:hostent-name))))
(:mop-direct posix:hostent :slot
 ((:name posix::aliases) (:ordinal 2) (:type common-lisp:list) (:initargs (:aliases)) (:readers (posix:hostent-aliases))))
(:mop-direct posix:hostent :slot
 ((:name posix::addr-list) (:ordinal 3) (:type common-lisp:list) (:initargs (:addr-list)) (:readers (posix:hostent-addr-list))))
(:mop-direct posix:hostent :slot
 ((:name posix::addrtype) (:ordinal 4) (:initform 2) (:type common-lisp:fixnum) (:initargs (:addrtype)) (:readers (posix:hostent-addrtype))))
(:mop-direct posix:hostent :prototype #<posix:hostent :name #<unbound> :aliases #<unbound> :addr-list #<unbound> :addrtype #<unbound>>)
(:mop-direct posix:user-info :superclass common-lisp:structure-object)
(:mop-direct posix:user-info :package-name "POSIX")
(:mop-direct posix:user-info :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct posix:user-info :classof clos:structure-class)
(:mop-direct posix:user-info :typeof clos:structure-class)
(:mop-direct posix:user-info :superclass common-lisp:structure-object)
(:mop-direct posix:user-info :slot
 ((:name posix::login-id) (:ordinal 1) (:initform "") (:type common-lisp:simple-string) (:initargs (:login-id))
  (:readers (posix:user-info-login-id))))
(:mop-direct posix:user-info :slot
 ((:name posix::passwd) (:ordinal 2) (:initform "") (:type common-lisp:simple-string) (:initargs (:passwd))
  (:readers (posix:user-info-passwd))))
(:mop-direct posix:user-info :slot
 ((:name posix:uid) (:ordinal 3) (:initform 0) (:type (common-lisp:unsigned-byte 32)) (:initargs (:uid)) (:readers (posix:user-info-uid))))
(:mop-direct posix:user-info :slot
 ((:name posix:gid) (:ordinal 4) (:initform 0) (:type (common-lisp:unsigned-byte 32)) (:initargs (:gid)) (:readers (posix:user-info-gid))))
(:mop-direct posix:user-info :slot
 ((:name posix::full-name) (:ordinal 5) (:initform "") (:type common-lisp:simple-string) (:initargs (:full-name))
  (:readers (posix:user-info-full-name))))
(:mop-direct posix:user-info :slot
 ((:name posix::home-dir) (:ordinal 6) (:initform "") (:type common-lisp:simple-string) (:initargs (:home-dir))
  (:readers (posix:user-info-home-dir))))
(:mop-direct posix:user-info :slot
 ((:name ext:shell) (:ordinal 7) (:initform "") (:type common-lisp:simple-string) (:initargs (:shell)) (:readers (posix:user-info-shell))))
(:mop-direct posix:user-info :prototype
 #<posix:user-info :login-id #<unbound> :passwd #<unbound> :uid #<unbound> :gid #<unbound> :full-name #<unbound> :home-dir #<unbound>
   :shell #<unbound>>)
(:mop-direct posix:group-info :superclass common-lisp:structure-object)
(:mop-direct posix:group-info :package-name "POSIX")
(:mop-direct posix:group-info :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct posix:group-info :classof clos:structure-class)
(:mop-direct posix:group-info :typeof clos:structure-class)
(:mop-direct posix:group-info :superclass common-lisp:structure-object)
(:mop-direct posix:group-info :slot
 ((:name posix::name) (:ordinal 1) (:initform "") (:type common-lisp:simple-string) (:initargs (:name)) (:readers (posix:group-info-name))))
(:mop-direct posix:group-info :slot
 ((:name posix:gid) (:ordinal 2) (:initform 0) (:type (common-lisp:unsigned-byte 32)) (:initargs (:gid)) (:readers (posix:group-info-gid))))
(:mop-direct posix:group-info :slot
 ((:name posix::members) (:ordinal 3) (:type common-lisp:list) (:initargs (:members)) (:readers (posix:group-info-members))))
(:mop-direct posix:group-info :prototype #<posix:group-info :name #<unbound> :gid #<unbound> :members #<unbound>>)
(:mop-direct posix:file-stat :superclass common-lisp:structure-object)
(:mop-direct posix:file-stat :package-name "POSIX")
(:mop-direct posix:file-stat :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct posix:file-stat :classof clos:structure-class)
(:mop-direct posix:file-stat :typeof clos:structure-class)
(:mop-direct posix:file-stat :superclass common-lisp:structure-object)
(:mop-direct posix:file-stat :slot ((:name posix::file) (:ordinal 1) (:initargs (:file)) (:readers (posix:file-stat-file))))
(:mop-direct posix:file-stat :slot
 ((:name posix::dev) (:ordinal 2) (:initform 0) (:type (common-lisp:unsigned-byte 32)) (:initargs (:dev)) (:readers (posix:file-stat-dev))))
(:mop-direct posix:file-stat :slot
 ((:name posix::ino) (:ordinal 3) (:initform 0) (:type (common-lisp:unsigned-byte 32)) (:initargs (:ino)) (:readers (posix:file-stat-ino))))
(:mop-direct posix:file-stat :slot
 ((:name posix::mode) (:ordinal 4) (:type common-lisp:list) (:initargs (:mode)) (:readers (posix:file-stat-mode))))
(:mop-direct posix:file-stat :slot
 ((:name posix::nlink) (:ordinal 5) (:initform 1) (:type (common-lisp:unsigned-byte 32)) (:initargs (:nlink))
  (:readers (posix:file-stat-nlink))))
(:mop-direct posix:file-stat :slot
 ((:name posix:uid) (:ordinal 6) (:type (common-lisp:or common-lisp:null (common-lisp:unsigned-byte 32))) (:initargs (:uid))
  (:readers (posix:file-stat-uid))))
(:mop-direct posix:file-stat :slot
 ((:name posix:gid) (:ordinal 7) (:type (common-lisp:or common-lisp:null (common-lisp:unsigned-byte 32))) (:initargs (:gid))
  (:readers (posix:file-stat-gid))))
(:mop-direct posix:file-stat :slot
 ((:name posix::rdev) (:ordinal 8) (:type (common-lisp:or common-lisp:null (common-lisp:unsigned-byte 32))) (:initargs (:rdev))
  (:readers (posix:file-stat-rdev))))
(:mop-direct posix:file-stat :slot
 ((:name posix::size) (:ordinal 9) (:initform 0) (:type (common-lisp:unsigned-byte 32)) (:initargs (:size)) (:readers (posix:file-stat-size))))
(:mop-direct posix:file-stat :slot
 ((:name posix::blksize) (:ordinal 10) (:type (common-lisp:or common-lisp:null (common-lisp:unsigned-byte 32))) (:initargs (:blksize))
  (:readers (posix:file-stat-blksize))))
(:mop-direct posix:file-stat :slot
 ((:name posix::blocks) (:ordinal 11) (:type (common-lisp:or common-lisp:null (common-lisp:unsigned-byte 32))) (:initargs (:blocks))
  (:readers (posix:file-stat-blocks))))
(:mop-direct posix:file-stat :slot
 ((:name posix::atime) (:ordinal 12) (:initform 0) (:type (common-lisp:integer 0)) (:initargs (:atime)) (:readers (posix:file-stat-atime))))
(:mop-direct posix:file-stat :slot
 ((:name posix::mtime) (:ordinal 13) (:initform 0) (:type (common-lisp:integer 0)) (:initargs (:mtime)) (:readers (posix:file-stat-mtime))))
(:mop-direct posix:file-stat :slot
 ((:name posix::ctime) (:ordinal 14) (:initform 0) (:type (common-lisp:integer 0)) (:initargs (:ctime)) (:readers (posix:file-stat-ctime))))
(:mop-direct posix:file-stat :prototype
 #<posix:file-stat :file #<unbound> :dev #<unbound> :ino #<unbound> :mode #<unbound> :nlink #<unbound> :uid #<unbound> :gid #<unbound>
   :rdev #<unbound> :size #<unbound> :blksize #<unbound> :blocks #<unbound> :atime #<unbound> :mtime #<unbound> :ctime #<unbound>>)
(:mop-direct posix:stat-vfs :superclass common-lisp:structure-object)
(:mop-direct posix:stat-vfs :package-name "POSIX")
(:mop-direct posix:stat-vfs :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct posix:stat-vfs :classof clos:structure-class)
(:mop-direct posix:stat-vfs :typeof clos:structure-class)
(:mop-direct posix:stat-vfs :superclass common-lisp:structure-object)
(:mop-direct posix:stat-vfs :slot ((:name posix::file) (:ordinal 1) (:initargs (:file)) (:readers (posix:stat-vfs-file))))
(:mop-direct posix:stat-vfs :slot
 ((:name posix::bsize) (:ordinal 2) (:type (common-lisp:or common-lisp:null (common-lisp:unsigned-byte 32))) (:initargs (:bsize))
  (:readers (posix:stat-vfs-bsize))))
(:mop-direct posix:stat-vfs :slot
 ((:name posix::frsize) (:ordinal 3) (:type (common-lisp:or common-lisp:null (common-lisp:unsigned-byte 32))) (:initargs (:frsize))
  (:readers (posix:stat-vfs-frsize))))
(:mop-direct posix:stat-vfs :slot
 ((:name posix::blocks) (:ordinal 4) (:type (common-lisp:or common-lisp:null (common-lisp:unsigned-byte 32))) (:initargs (:blocks))
  (:readers (posix:stat-vfs-blocks))))
(:mop-direct posix:stat-vfs :slot
 ((:name posix::bfree) (:ordinal 5) (:type (common-lisp:or common-lisp:null (common-lisp:unsigned-byte 32))) (:initargs (:bfree))
  (:readers (posix:stat-vfs-bfree))))
(:mop-direct posix:stat-vfs :slot
 ((:name posix::bavail) (:ordinal 6) (:type (common-lisp:or common-lisp:null (common-lisp:unsigned-byte 32))) (:initargs (:bavail))
  (:readers (posix:stat-vfs-bavail))))
(:mop-direct posix:stat-vfs :slot
 ((:name posix::files) (:ordinal 7) (:type (common-lisp:or common-lisp:null (common-lisp:unsigned-byte 32))) (:initargs (:files))
  (:readers (posix:stat-vfs-files))))
(:mop-direct posix:stat-vfs :slot
 ((:name posix::ffree) (:ordinal 8) (:type (common-lisp:or common-lisp:null (common-lisp:unsigned-byte 32))) (:initargs (:ffree))
  (:readers (posix:stat-vfs-ffree))))
(:mop-direct posix:stat-vfs :slot
 ((:name posix::favail) (:ordinal 9) (:type (common-lisp:or common-lisp:null (common-lisp:unsigned-byte 32))) (:initargs (:favail))
  (:readers (posix:stat-vfs-favail))))
(:mop-direct posix:stat-vfs :slot
 ((:name posix::fsid) (:ordinal 10) (:type (common-lisp:or common-lisp:null (common-lisp:unsigned-byte 32))) (:initargs (:fsid))
  (:readers (posix:stat-vfs-fsid))))
(:mop-direct posix:stat-vfs :slot
 ((:name posix::flag) (:ordinal 11) (:type common-lisp:list) (:initargs (:flag)) (:readers (posix:stat-vfs-flag))))
(:mop-direct posix:stat-vfs :slot
 ((:name posix::namemax) (:ordinal 12) (:type (common-lisp:or common-lisp:null (common-lisp:unsigned-byte 32))) (:initargs (:namemax))
  (:readers (posix:stat-vfs-namemax))))
(:mop-direct posix:stat-vfs :slot
 ((:name posix::vol-name) (:ordinal 13) (:type (common-lisp:or common-lisp:null common-lisp:string)) (:initargs (:vol-name))
  (:readers (posix:stat-vfs-vol-name))))
(:mop-direct posix:stat-vfs :slot
 ((:name posix::fs-type) (:ordinal 14) (:type (common-lisp:or common-lisp:null common-lisp:string)) (:initargs (:fs-type))
  (:readers (posix:stat-vfs-fs-type))))
(:mop-direct posix:stat-vfs :prototype
 #<posix:stat-vfs :file #<unbound> :bsize #<unbound> :frsize #<unbound> :blocks #<unbound> :bfree #<unbound> :bavail #<unbound>
   :files #<unbound> :ffree #<unbound> :favail #<unbound> :fsid #<unbound> :flag #<unbound> :namemax #<unbound> :vol-name #<unbound>
   :fs-type #<unbound>>)
(:mop-direct posix:uname :superclass common-lisp:structure-object)
(:mop-direct posix:uname :package-name "POSIX")
(:mop-direct posix:uname :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct posix:uname :classof clos:structure-class)
(:mop-direct posix:uname :typeof clos:structure-class)
(:mop-direct posix:uname :superclass common-lisp:structure-object)
(:mop-direct posix:uname :slot
 ((:name posix::sysname) (:ordinal 1) (:initform "") (:type common-lisp:simple-string) (:initargs (:sysname)) (:readers (posix:uname-sysname))))
(:mop-direct posix:uname :slot
 ((:name posix::nodename) (:ordinal 2) (:initform "") (:type common-lisp:simple-string) (:initargs (:nodename))
  (:readers (posix:uname-nodename))))
(:mop-direct posix:uname :slot
 ((:name posix::release) (:ordinal 3) (:initform "") (:type common-lisp:simple-string) (:initargs (:release)) (:readers (posix:uname-release))))
(:mop-direct posix:uname :slot
 ((:name posix::version) (:ordinal 4) (:initform "") (:type common-lisp:simple-string) (:initargs (:version)) (:readers (posix:uname-version))))
(:mop-direct posix:uname :slot
 ((:name posix::machine) (:ordinal 5) (:initform "") (:type common-lisp:simple-string) (:initargs (:machine)) (:readers (posix:uname-machine))))
(:mop-direct posix:uname :prototype
 #<posix:uname :sysname #<unbound> :nodename #<unbound> :release #<unbound> :version #<unbound> :machine #<unbound>>)
(:mop-direct posix:rlimit :superclass common-lisp:structure-object)
(:mop-direct posix:rlimit :package-name "POSIX")
(:mop-direct posix:rlimit :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct posix:rlimit :classof clos:structure-class)
(:mop-direct posix:rlimit :typeof clos:structure-class)
(:mop-direct posix:rlimit :superclass common-lisp:structure-object)
(:mop-direct posix:rlimit :slot
 ((:name posix::cur) (:ordinal 1) (:type (common-lisp:or common-lisp:null (common-lisp:unsigned-byte 32))) (:initargs (:cur))
  (:readers (posix:rlimit-cur))))
(:mop-direct posix:rlimit :slot
 ((:name common-lisp:max) (:ordinal 2) (:type (common-lisp:or common-lisp:null (common-lisp:unsigned-byte 32))) (:initargs (:max))
  (:readers (posix:rlimit-max))))
(:mop-direct posix:rlimit :prototype #<posix:rlimit :cur #<unbound> :max #<unbound>>)
(:mop-direct posix:usage :superclass common-lisp:structure-object)
(:mop-direct posix:usage :package-name "POSIX")
(:mop-direct posix:usage :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct posix:usage :classof clos:structure-class)
(:mop-direct posix:usage :typeof clos:structure-class)
(:mop-direct posix:usage :superclass common-lisp:structure-object)
(:mop-direct posix:usage :slot
 ((:name posix::user-time) (:ordinal 1) (:initform 0.0d0) (:type common-lisp:double-float) (:initargs (:user-time))
  (:readers (posix:usage-user-time))))
(:mop-direct posix:usage :slot
 ((:name posix::system-time) (:ordinal 2) (:initform 0.0d0) (:type common-lisp:double-float) (:initargs (:system-time))
  (:readers (posix:usage-system-time))))
(:mop-direct posix:usage :slot
 ((:name posix::max-rss) (:ordinal 3) (:initform 0) (:type (common-lisp:signed-byte 32)) (:initargs (:max-rss))
  (:readers (posix:usage-max-rss))))
(:mop-direct posix:usage :slot
 ((:name posix::shared-memory) (:ordinal 4) (:initform 0) (:type (common-lisp:signed-byte 32)) (:initargs (:shared-memory))
  (:readers (posix:usage-shared-memory))))
(:mop-direct posix:usage :slot
 ((:name posix::data-memory) (:ordinal 5) (:initform 0) (:type (common-lisp:signed-byte 32)) (:initargs (:data-memory))
  (:readers (posix:usage-data-memory))))
(:mop-direct posix:usage :slot
 ((:name posix::stack-memory) (:ordinal 6) (:initform 0) (:type (common-lisp:signed-byte 32)) (:initargs (:stack-memory))
  (:readers (posix:usage-stack-memory))))
(:mop-direct posix:usage :slot
 ((:name posix::minor-page-faults) (:ordinal 7) (:initform 0) (:type (common-lisp:signed-byte 32)) (:initargs (:minor-page-faults))
  (:readers (posix:usage-minor-page-faults))))
(:mop-direct posix:usage :slot
 ((:name posix::major-page-faults) (:ordinal 8) (:initform 0) (:type (common-lisp:signed-byte 32)) (:initargs (:major-page-faults))
  (:readers (posix:usage-major-page-faults))))
(:mop-direct posix:usage :slot
 ((:name posix::num-swaps) (:ordinal 9) (:initform 0) (:type (common-lisp:signed-byte 32)) (:initargs (:num-swaps))
  (:readers (posix:usage-num-swaps))))
(:mop-direct posix:usage :slot
 ((:name posix::blocks-input) (:ordinal 10) (:initform 0) (:type (common-lisp:signed-byte 32)) (:initargs (:blocks-input))
  (:readers (posix:usage-blocks-input))))
(:mop-direct posix:usage :slot
 ((:name posix::blocks-output) (:ordinal 11) (:initform 0) (:type (common-lisp:signed-byte 32)) (:initargs (:blocks-output))
  (:readers (posix:usage-blocks-output))))
(:mop-direct posix:usage :slot
 ((:name posix::messages-sent) (:ordinal 12) (:initform 0) (:type (common-lisp:signed-byte 32)) (:initargs (:messages-sent))
  (:readers (posix:usage-messages-sent))))
(:mop-direct posix:usage :slot
 ((:name posix::messages-received) (:ordinal 13) (:initform 0) (:type (common-lisp:signed-byte 32)) (:initargs (:messages-received))
  (:readers (posix:usage-messages-received))))
(:mop-direct posix:usage :slot
 ((:name posix::signals) (:ordinal 14) (:initform 0) (:type (common-lisp:signed-byte 32)) (:initargs (:signals))
  (:readers (posix:usage-signals))))
(:mop-direct posix:usage :slot
 ((:name posix::context-switches-voluntary) (:ordinal 15) (:initform 0) (:type (common-lisp:signed-byte 32))
  (:initargs (:context-switches-voluntary)) (:readers (posix:usage-context-switches-voluntary))))
(:mop-direct posix:usage :slot
 ((:name posix::context-switches-involuntary) (:ordinal 16) (:initform 0) (:type (common-lisp:signed-byte 32))
  (:initargs (:context-switches-involuntary)) (:readers (posix:usage-context-switches-involuntary))))
(:mop-direct posix:usage :prototype
 #<posix:usage :user-time #<unbound> :system-time #<unbound> :max-rss #<unbound> :shared-memory #<unbound> :data-memory #<unbound>
   :stack-memory #<unbound> :minor-page-faults #<unbound> :major-page-faults #<unbound> :num-swaps #<unbound> :blocks-input #<unbound>
   :blocks-output #<unbound> :messages-sent #<unbound> :messages-received #<unbound> :signals #<unbound> :context-switches-voluntary #<unbound>
   :context-switches-involuntary #<unbound>>)
(:mop-direct posix:file-info :superclass common-lisp:structure-object)
(:mop-direct posix:file-info :package-name "POSIX")
(:mop-direct posix:file-info :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct posix:file-info :classof clos:structure-class)
(:mop-direct posix:file-info :typeof clos:structure-class)
(:mop-direct posix:file-info :superclass common-lisp:structure-object)
(:mop-direct posix:file-info :slot ((:name posix::attributes) (:ordinal 1) (:initargs (:attributes)) (:readers (posix:file-info-attributes))))
(:mop-direct posix:file-info :slot ((:name posix::ctime) (:ordinal 2) (:initargs (:ctime)) (:readers (posix:file-info-ctime))))
(:mop-direct posix:file-info :slot ((:name posix::atime) (:ordinal 3) (:initargs (:atime)) (:readers (posix:file-info-atime))))
(:mop-direct posix:file-info :slot ((:name posix::wtime) (:ordinal 4) (:initargs (:wtime)) (:readers (posix:file-info-wtime))))
(:mop-direct posix:file-info :slot ((:name posix::size) (:ordinal 5) (:initargs (:size)) (:readers (posix:file-info-size))))
(:mop-direct posix:file-info :slot ((:name posix::name) (:ordinal 6) (:initargs (:name)) (:readers (posix:file-info-name))))
(:mop-direct posix:file-info :slot ((:name posix::name-short) (:ordinal 7) (:initargs (:name-short)) (:readers (posix:file-info-name-short))))
(:mop-direct posix:file-info :prototype
 #<posix:file-info :attributes #<unbound> :ctime #<unbound> :atime #<unbound> :wtime #<unbound> :size #<unbound> :name #<unbound>
   :name-short #<unbound>>)
(:mop-direct posix:service :superclass common-lisp:structure-object)
(:mop-direct posix:service :package-name "POSIX")
(:mop-direct posix:service :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct posix:service :classof clos:structure-class)
(:mop-direct posix:service :typeof clos:structure-class)
(:mop-direct posix:service :superclass common-lisp:structure-object)
(:mop-direct posix:service :slot
 ((:name posix::name) (:ordinal 1) (:initform "") (:type common-lisp:string) (:initargs (:name)) (:readers (posix:service-name))
  (:writers ((common-lisp:setf posix:service-name)))))
(:mop-direct posix:service :slot
 ((:name posix::aliases) (:ordinal 2) (:type common-lisp:list) (:initargs (:aliases)) (:readers (posix:service-aliases))
  (:writers ((common-lisp:setf posix:service-aliases)))))
(:mop-direct posix:service :slot
 ((:name posix::port) (:ordinal 3) (:initform 0) (:type common-lisp:integer) (:initargs (:port)) (:readers (posix:service-port))
  (:writers ((common-lisp:setf posix:service-port)))))
(:mop-direct posix:service :slot
 ((:name posix::proto) (:ordinal 4) (:initform "tcp") (:type common-lisp:string) (:initargs (:proto)) (:readers (posix:service-proto))
  (:writers ((common-lisp:setf posix:service-proto)))))
(:mop-direct posix:service :prototype #<posix:service :name #<unbound> :aliases #<unbound> :port #<unbound> :proto #<unbound>>)
(:mop-direct regexp:match :superclass common-lisp:structure-object)
(:mop-direct regexp:match :package-name "REGEXP")
(:mop-direct regexp:match :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct regexp:match :classof clos:structure-class)
(:mop-direct regexp:match :typeof clos:structure-class)
(:mop-direct regexp:match :superclass common-lisp:structure-object)
(:mop-direct regexp:match :slot
 ((:name regexp::start) (:ordinal 1) (:initargs (:start)) (:readers (regexp:match-start)) (:writers ((common-lisp:setf regexp:match-start)))))
(:mop-direct regexp:match :slot
 ((:name regexp::end) (:ordinal 2) (:initargs (:end)) (:readers (regexp:match-end)) (:writers ((common-lisp:setf regexp:match-end)))))
(:mop-direct regexp:match :prototype #S(regexp:match :start #<unbound> :end #<unbound>))
(:mop-direct ql-gunzipper::sliding-window-stream :superclass common-lisp:structure-object)
(:mop-direct ql-gunzipper::sliding-window-stream :package-name "QL-GUNZIPPER")
(:mop-direct ql-gunzipper::sliding-window-stream :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct ql-gunzipper::sliding-window-stream :classof clos:structure-class)
(:mop-direct ql-gunzipper::sliding-window-stream :typeof clos:structure-class)
(:mop-direct ql-gunzipper::sliding-window-stream :superclass common-lisp:structure-object)
(:mop-direct ql-gunzipper::sliding-window-stream :slot
 ((:name common-lisp:stream) (:ordinal 1) (:type common-lisp:stream) (:initargs (:stream))
  (:readers (ql-gunzipper::sliding-window-stream-stream))))
(:mop-direct ql-gunzipper::sliding-window-stream :slot
 ((:name ql-gunzipper::buffer) (:ordinal 2)
  (:initform (common-lisp:make-array ql-gunzipper::+sliding-window-size+ :element-type '(common-lisp:unsigned-byte 8)))
  (:type (common-lisp:simple-array (common-lisp:unsigned-byte 8) (32768))) (:initargs (:buffer))
  (:readers (ql-gunzipper::sliding-window-stream-buffer))))
(:mop-direct ql-gunzipper::sliding-window-stream :slot
 ((:name ql-gunzipper::buffer-end) (:ordinal 3) (:initform 0) (:type common-lisp:fixnum) (:initargs (:buffer-end))
  (:readers (ql-gunzipper::sliding-window-stream-buffer-end)) (:writers ((common-lisp:setf ql-gunzipper::sliding-window-stream-buffer-end)))))
(:mop-direct ql-gunzipper::sliding-window-stream :slot
 ((:name ql-gunzipper::checksum) (:ordinal 4) (:type common-lisp:symbol) (:initargs (:checksum))
  (:readers (ql-gunzipper::sliding-window-stream-checksum))))
(:mop-direct ql-gunzipper::sliding-window-stream :slot
 ((:name ql-gunzipper::checksum-value) (:ordinal 5) (:initform 0) (:type (common-lisp:unsigned-byte 32)) (:initargs (:checksum-value))
  (:readers (ql-gunzipper::sliding-window-stream-checksum-value))
  (:writers ((common-lisp:setf ql-gunzipper::sliding-window-stream-checksum-value)))))
(:mop-direct ql-gunzipper::sliding-window-stream :prototype
 #S(ql-gunzipper::sliding-window-stream :stream #<unbound> :buffer #<unbound> :buffer-end #<unbound> :checksum #<unbound>
    :checksum-value #<unbound>))
(:mop-direct ql-gunzipper::bit-stream :superclass common-lisp:structure-object)
(:mop-direct ql-gunzipper::bit-stream :package-name "QL-GUNZIPPER")
(:mop-direct ql-gunzipper::bit-stream :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct ql-gunzipper::bit-stream :classof clos:structure-class)
(:mop-direct ql-gunzipper::bit-stream :typeof clos:structure-class)
(:mop-direct ql-gunzipper::bit-stream :superclass common-lisp:structure-object)
(:mop-direct ql-gunzipper::bit-stream :slot
 ((:name common-lisp:stream) (:ordinal 1) (:type common-lisp:stream) (:initargs (:stream)) (:readers (ql-gunzipper::bit-stream-stream))))
(:mop-direct ql-gunzipper::bit-stream :slot
 ((:name ql-gunzipper::next-byte) (:ordinal 2) (:initform 0) (:type common-lisp:fixnum) (:initargs (:next-byte))
  (:readers (ql-gunzipper::bit-stream-next-byte)) (:writers ((common-lisp:setf ql-gunzipper::bit-stream-next-byte)))))
(:mop-direct ql-gunzipper::bit-stream :slot
 ((:name ql-gunzipper::bits) (:ordinal 3) (:initform 0) (:type (common-lisp:unsigned-byte 29)) (:initargs (:bits))
  (:readers (ql-gunzipper::bit-stream-bits)) (:writers ((common-lisp:setf ql-gunzipper::bit-stream-bits)))))
(:mop-direct ql-gunzipper::bit-stream :slot
 ((:name ql-gunzipper::bit-count) (:ordinal 4) (:initform 0) (:type (common-lisp:unsigned-byte 8)) (:initargs (:bit-count))
  (:readers (ql-gunzipper::bit-stream-bit-count)) (:writers ((common-lisp:setf ql-gunzipper::bit-stream-bit-count)))))
(:mop-direct ql-gunzipper::bit-stream :prototype
 #S(ql-gunzipper::bit-stream :stream #<unbound> :next-byte #<unbound> :bits #<unbound> :bit-count #<unbound>))
(:mop-direct ql-gunzipper::decode-tree :superclass common-lisp:structure-object)
(:mop-direct ql-gunzipper::decode-tree :package-name "QL-GUNZIPPER")
(:mop-direct ql-gunzipper::decode-tree :precedance (common-lisp:structure-object common-lisp:t))
(:mop-direct ql-gunzipper::decode-tree :classof clos:structure-class)
(:mop-direct ql-gunzipper::decode-tree :typeof clos:structure-class)
(:mop-direct ql-gunzipper::decode-tree :superclass common-lisp:structure-object)
(:mop-direct ql-gunzipper::decode-tree :slot
 ((:name ql-gunzipper::length-count) (:ordinal 1) (:initform (common-lisp:make-array 16 :element-type 'common-lisp:fixnum :initial-element 0))
  (:type (common-lisp:simple-array common-lisp:fixnum (common-lisp:*))) (:initargs (:length-count))
  (:readers (ql-gunzipper::decode-tree-length-count))))
(:mop-direct ql-gunzipper::decode-tree :slot
 ((:name ql-gunzipper::code-symbols) (:ordinal 2) (:initform (common-lisp:make-array 16 :element-type 'common-lisp:fixnum :initial-element 0))
  (:type (common-lisp:simple-array common-lisp:fixnum (common-lisp:*))) (:initargs (:code-symbols))
  (:readers (ql-gunzipper::decode-tree-code-symbols)) (:writers ((common-lisp:setf ql-gunzipper::decode-tree-code-symbols)))))
(:mop-direct ql-gunzipper::decode-tree :prototype #S(ql-gunzipper::decode-tree :length-count #<unbound> :code-symbols #<unbound>))
(:mop-direct common-lisp:structure-object :prototype #<common-lisp:structure-object>)
(:mop-direct common-lisp:standard-object :superclass common-lisp:t)
(:mop-direct ql-impl:allegro :superclass common-lisp:standard-object)
(:mop-direct ql-impl:lisp :superclass common-lisp:standard-object)
(:mop-direct asdf-2.26:operation :superclass common-lisp:standard-object)
(:mop-direct asdf-2.26::proto-system :superclass common-lisp:standard-object)
(:mop-direct asdf-2.26:component :superclass common-lisp:standard-object)
(:mop-direct gstream:generic-stream-controller :superclass common-lisp:standard-object)
(:mop-direct common-lisp:condition :superclass common-lisp:standard-object)
(:mop-direct gray:fundamental-stream :superclass common-lisp:standard-object)
(:mop-direct clos:funcallable-standard-object :superclass common-lisp:standard-object)
(:mop-direct clos:standard-stablehash :superclass common-lisp:standard-object)
(:mop-direct clos:metaobject :superclass common-lisp:standard-object)
(:mop-direct ql-impl:abcl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:ccl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:clasp :superclass common-lisp:standard-object)
(:mop-direct ql-impl:clisp :superclass common-lisp:standard-object)
(:mop-direct ql-impl:cmucl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:scl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:lispworks :superclass common-lisp:standard-object)
(:mop-direct ql-impl:ecl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:mkcl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:sbcl :superclass common-lisp:standard-object)
(:mop-direct ql-progress::progress-bar :superclass common-lisp:standard-object)
(:mop-direct ql-http::matcher :superclass common-lisp:standard-object)
(:mop-direct ql-http::cbuf :superclass common-lisp:standard-object)
(:mop-direct ql-http::octet-sink :superclass common-lisp:standard-object)
(:mop-direct ql-http::header :superclass common-lisp:standard-object)
(:mop-direct ql-http:url :superclass common-lisp:standard-object)
(:mop-direct ql-cdb::record-pointer :superclass common-lisp:standard-object)
(:mop-direct ql-cdb::hash-table-bucket :superclass common-lisp:standard-object)
(:mop-direct ql-cdb::cdb-writer :superclass common-lisp:standard-object)
(:mop-direct ql-dist:dist :superclass common-lisp:standard-object)
(:mop-direct ql-dist::preference-mixin :superclass common-lisp:standard-object)
(:mop-direct quicklisp-client::load-strategy :superclass common-lisp:standard-object)
(:mop-direct quicklisp-client::client-file-info :superclass common-lisp:standard-object)
(:mop-direct quicklisp-client::client-info :superclass common-lisp:standard-object)
(:mop-direct ql-bundle:bundle :superclass common-lisp:standard-object)
(:mop-direct uiop/launch-program::process-info :superclass common-lisp:standard-object)
(:mop-direct asdf/session:session :superclass common-lisp:standard-object)
(:mop-direct asdf/component:component :superclass common-lisp:standard-object)
(:mop-direct asdf/operation:operation :superclass common-lisp:standard-object)
(:mop-direct asdf/system:proto-system :superclass common-lisp:standard-object)
(:mop-direct asdf/session:forcing :superclass common-lisp:standard-object)
(:mop-direct asdf/plan:plan :superclass common-lisp:standard-object)
(:mop-direct asdf/plan:action-status :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:lisp :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:allegro :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:abcl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:ccl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:clasp :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:clisp :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:cmucl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:scl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:ecl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:lispworks :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:sbcl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:mkcl :superclass common-lisp:standard-object)
(:mop-direct qlqs-progress::progress-bar :superclass common-lisp:standard-object)
(:mop-direct qlqs-http::matcher :superclass common-lisp:standard-object)
(:mop-direct qlqs-http::cbuf :superclass common-lisp:standard-object)
(:mop-direct qlqs-http::octet-sink :superclass common-lisp:standard-object)
(:mop-direct qlqs-http::header :superclass common-lisp:standard-object)
(:mop-direct qlqs-http::url :superclass common-lisp:standard-object)
(:mop-direct quicklisp-quickstart::client-info :superclass common-lisp:standard-object)
(:mop-direct common-lisp:standard-object :package-name "COMMON-LISP")
(:mop-direct common-lisp:standard-object :classof clos:standard-class)
(:mop-direct common-lisp:standard-object :typeof clos:standard-class)
(:mop-direct common-lisp:standard-object :superclass common-lisp:t)
(:mop-direct ql-impl:allegro :superclass common-lisp:standard-object)
(:mop-direct ql-impl:allegro :package-name "QL-IMPL")
(:mop-direct ql-impl:allegro :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-impl:allegro :classof clos:standard-class)
(:mop-direct ql-impl:allegro :typeof clos:standard-class)
(:mop-direct ql-impl:allegro :superclass common-lisp:standard-object)
(:mop-direct ql-impl:allegro :prototype #<ql-impl:allegro #x000335B10108>)
(:mop-direct ql-impl:lisp :superclass common-lisp:standard-object)
(:mop-direct ql-impl:lisp :package-name "QL-IMPL")
(:mop-direct ql-impl:lisp :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-impl:lisp :classof clos:standard-class)
(:mop-direct ql-impl:lisp :typeof clos:standard-class)
(:mop-direct ql-impl:lisp :superclass common-lisp:standard-object)
(:mop-direct ql-impl:lisp :prototype #<ql-impl:lisp #x000335B16328>)
(:mop-direct asdf-2.26:operation :superclass common-lisp:standard-object)
(:mop-direct asdf-2.26:test-op :superclass asdf-2.26:operation)
(:mop-direct asdf-2.26::basic-load-op :superclass asdf-2.26:operation)
(:mop-direct asdf-2.26:compile-op :superclass asdf-2.26:operation)
(:mop-direct asdf-2.26:operation :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:operation :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:operation :classof clos:standard-class)
(:mop-direct asdf-2.26:operation :typeof clos:standard-class)
(:mop-direct asdf-2.26:operation :superclass common-lisp:standard-object)
(:mop-direct asdf-2.26:operation :slot
 ((:name asdf-2.26::forced) (:ordinal 1) (:initargs (:force)) (:readers (asdf-2.26::operation-forced))
  (:writers ((common-lisp:setf asdf-2.26::operation-forced)))))
(:mop-direct asdf-2.26:operation :slot
 ((:name asdf-2.26::forced-not) (:ordinal 2) (:initargs (:force-not)) (:readers (asdf-2.26::operation-forced-not))
  (:writers ((common-lisp:setf asdf-2.26::operation-forced-not)))))
(:mop-direct asdf-2.26:operation :slot
 ((:name asdf-2.26::original-initargs) (:ordinal 3) (:initargs (:original-initargs)) (:readers (asdf-2.26::operation-original-initargs))
  (:writers ((common-lisp:setf asdf-2.26::operation-original-initargs)))))
(:mop-direct asdf-2.26:operation :slot
 ((:name asdf-2.26::visited-nodes) (:ordinal 4) (:initform (common-lisp:make-hash-table :test 'common-lisp:equal))
  (:readers (asdf-2.26::operation-visited-nodes)) (:writers ((common-lisp:setf asdf-2.26::operation-visited-nodes)))))
(:mop-direct asdf-2.26:operation :slot
 ((:name asdf-2.26::visiting-nodes) (:ordinal 5) (:initform (common-lisp:make-hash-table :test 'common-lisp:equal))
  (:readers (asdf-2.26::operation-visiting-nodes)) (:writers ((common-lisp:setf asdf-2.26::operation-visiting-nodes)))))
(:mop-direct asdf-2.26:operation :slot
 ((:name asdf-2.26::parent) (:ordinal 6) (:initargs (:parent)) (:readers (asdf-2.26::operation-parent))
  (:writers ((common-lisp:setf asdf-2.26::operation-parent)))))
(:mop-direct asdf-2.26:test-op :superclass asdf-2.26:operation)
(:mop-direct asdf-2.26:test-op :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:test-op :precedance (asdf-2.26:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:test-op :classof clos:standard-class)
(:mop-direct asdf-2.26:test-op :typeof clos:standard-class)
(:mop-direct asdf-2.26:test-op :superclass asdf-2.26:operation)
(:mop-direct asdf-2.26:test-op :prototype #<asdf-2.26:test-op  #x000335962B50>)
(:mop-direct asdf-2.26::basic-load-op :superclass asdf-2.26:operation)
(:mop-direct asdf-2.26:load-source-op :superclass asdf-2.26::basic-load-op)
(:mop-direct asdf-2.26:load-op :superclass asdf-2.26::basic-load-op)
(:mop-direct asdf-2.26::basic-load-op :package-name "ASDF-2.26")
(:mop-direct asdf-2.26::basic-load-op :precedance (asdf-2.26:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26::basic-load-op :classof clos:standard-class)
(:mop-direct asdf-2.26::basic-load-op :typeof clos:standard-class)
(:mop-direct asdf-2.26::basic-load-op :superclass asdf-2.26:operation)
(:mop-direct asdf-2.26:load-source-op :superclass asdf-2.26::basic-load-op)
(:mop-direct asdf-2.26:load-source-op :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:load-source-op :precedance (asdf-2.26::basic-load-op asdf-2.26:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:load-source-op :classof clos:standard-class)
(:mop-direct asdf-2.26:load-source-op :typeof clos:standard-class)
(:mop-direct asdf-2.26:load-source-op :superclass asdf-2.26::basic-load-op)
(:mop-direct asdf-2.26:load-source-op :prototype #<asdf-2.26:load-source-op  #x00033596FD88>)
(:mop-direct asdf-2.26:load-op :superclass asdf-2.26::basic-load-op)
(:mop-direct asdf-2.26:load-op :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:load-op :precedance (asdf-2.26::basic-load-op asdf-2.26:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:load-op :classof clos:standard-class)
(:mop-direct asdf-2.26:load-op :typeof clos:standard-class)
(:mop-direct asdf-2.26:load-op :superclass asdf-2.26::basic-load-op)
(:mop-direct asdf-2.26:load-op :prototype #<asdf-2.26:load-op  #x000335977518>)
(:mop-direct asdf-2.26::basic-load-op :prototype #<asdf-2.26::basic-load-op  #x00033597A838>)
(:mop-direct asdf-2.26:compile-op :superclass asdf-2.26:operation)
(:mop-direct asdf-2.26:compile-op :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:compile-op :precedance (asdf-2.26:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:compile-op :classof clos:standard-class)
(:mop-direct asdf-2.26:compile-op :typeof clos:standard-class)
(:mop-direct asdf-2.26:compile-op :superclass asdf-2.26:operation)
(:mop-direct asdf-2.26:compile-op :slot
 ((:name asdf-2.26::proclamations) (:ordinal 1) (:initargs (:proclamations)) (:readers (asdf-2.26::compile-op-proclamations))
  (:writers ((common-lisp:setf asdf-2.26::compile-op-proclamations)))))
(:mop-direct asdf-2.26:compile-op :slot
 ((:name asdf-2.26::on-warnings) (:ordinal 2) (:initform asdf-2.26:*compile-file-warnings-behaviour*) (:initargs (:on-warnings))
  (:readers (asdf-2.26:operation-on-warnings)) (:writers ((common-lisp:setf asdf-2.26:operation-on-warnings)))))
(:mop-direct asdf-2.26:compile-op :slot
 ((:name asdf-2.26::on-failure) (:ordinal 3) (:initform asdf-2.26:*compile-file-failure-behaviour*) (:initargs (:on-failure))
  (:readers (asdf-2.26:operation-on-failure)) (:writers ((common-lisp:setf asdf-2.26:operation-on-failure)))))
(:mop-direct asdf-2.26:compile-op :slot
 ((:name asdf-2.26::flags) (:ordinal 4) (:initargs (:flags)) (:readers (asdf-2.26::compile-op-flags))
  (:writers ((common-lisp:setf asdf-2.26::compile-op-flags)))))
(:mop-direct asdf-2.26:compile-op :prototype #<asdf-2.26:compile-op  #x00033598CFF8>)
(:mop-direct asdf-2.26:operation :prototype #<asdf-2.26:operation  #x000335990280>)
(:mop-direct asdf-2.26::proto-system :superclass common-lisp:standard-object)
(:mop-direct asdf-2.26:system :superclass asdf-2.26::proto-system)
(:mop-direct asdf-2.26::proto-system :package-name "ASDF-2.26")
(:mop-direct asdf-2.26::proto-system :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26::proto-system :classof clos:standard-class)
(:mop-direct asdf-2.26::proto-system :typeof clos:standard-class)
(:mop-direct asdf-2.26::proto-system :superclass common-lisp:standard-object)
(:mop-direct asdf-2.26::proto-system :slot ((:name asdf-2.26::name) (:ordinal 1)))
(:mop-direct asdf-2.26:system :superclass asdf-2.26:module)
(:mop-direct asdf-2.26:system :superclass asdf-2.26::proto-system)
(:mop-direct asdf-2.26:system :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:system :precedance
 (asdf-2.26:module asdf-2.26:component asdf-2.26::proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:system :classof clos:standard-class)
(:mop-direct asdf-2.26:system :typeof clos:standard-class)
(:mop-direct asdf-2.26:system :superclass asdf-2.26::proto-system)
(:mop-direct asdf-2.26:system :slot
 ((:name asdf-2.26::description) (:ordinal 1) (:initargs (:description)) (:readers (asdf-2.26:system-description))
  (:writers ((common-lisp:setf asdf-2.26:system-description)))))
(:mop-direct asdf-2.26:system :slot
 ((:name asdf-2.26::long-description) (:ordinal 2) (:initargs (:long-description)) (:readers (asdf-2.26:system-long-description))
  (:writers ((common-lisp:setf asdf-2.26:system-long-description)))))
(:mop-direct asdf-2.26:system :slot
 ((:name asdf-2.26::author) (:ordinal 3) (:initargs (:author)) (:readers (asdf-2.26:system-author))
  (:writers ((common-lisp:setf asdf-2.26:system-author)))))
(:mop-direct asdf-2.26:system :slot
 ((:name asdf-2.26::maintainer) (:ordinal 4) (:initargs (:maintainer)) (:readers (asdf-2.26:system-maintainer))
  (:writers ((common-lisp:setf asdf-2.26:system-maintainer)))))
(:mop-direct asdf-2.26:system :slot
 ((:name asdf-2.26::licence) (:ordinal 5) (:initargs (:licence :license)) (:readers (asdf-2.26:system-licence asdf-2.26:system-license))
  (:writers ((common-lisp:setf asdf-2.26:system-licence) (common-lisp:setf asdf-2.26:system-license)))))
(:mop-direct asdf-2.26:system :slot
 ((:name asdf-2.26:source-file) (:ordinal 6) (:initargs (:source-file)) (:readers (asdf-2.26::%system-source-file))
  (:writers (asdf-2.26::%set-system-source-file))))
(:mop-direct asdf-2.26:system :slot
 ((:name asdf-2.26::defsystem-depends-on) (:ordinal 7) (:initargs (:defsystem-depends-on)) (:readers (asdf-2.26::system-defsystem-depends-on))))

(:mop-direct asdf-2.26::proto-system :prototype #<asdf-2.26::proto-system #x0003359B2A60>)
(:mop-direct asdf-2.26:component :superclass common-lisp:standard-object)
(:mop-direct asdf-2.26:source-file :superclass asdf-2.26:component)
(:mop-direct asdf-2.26:module :superclass asdf-2.26:component)
(:mop-direct asdf-2.26:component :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:component :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:component :classof clos:standard-class)
(:mop-direct asdf-2.26:component :typeof clos:standard-class)
(:mop-direct asdf-2.26:component :superclass common-lisp:standard-object)
(:mop-direct asdf-2.26:component :slot
 ((:name asdf-2.26::name) (:ordinal 1) (:type common-lisp:string) (:initargs (:name)) (:readers (asdf-2.26:component-name))
  (:writers ((common-lisp:setf asdf-2.26:component-name)))))
(:mop-direct asdf-2.26:component :slot
 ((:name asdf-2.26:version) (:ordinal 2) (:initargs (:version)) (:readers (asdf-2.26:component-version))
  (:writers ((common-lisp:setf asdf-2.26:component-version)))))
(:mop-direct asdf-2.26:component :slot
 ((:name asdf-2.26::description) (:ordinal 3) (:initargs (:description)) (:readers (asdf-2.26::component-description))
  (:writers ((common-lisp:setf asdf-2.26::component-description)))))
(:mop-direct asdf-2.26:component :slot
 ((:name asdf-2.26::long-description) (:ordinal 4) (:initargs (:long-description)) (:readers (asdf-2.26::component-long-description))
  (:writers ((common-lisp:setf asdf-2.26::component-long-description)))))
(:mop-direct asdf-2.26:component :slot
 ((:name asdf-2.26::load-dependencies) (:ordinal 5) (:readers (asdf-2.26::component-load-dependencies))
  (:writers ((common-lisp:setf asdf-2.26::component-load-dependencies)))))
(:mop-direct asdf-2.26:component :slot
 ((:name asdf-2.26::in-order-to) (:ordinal 6) (:initargs (:in-order-to)) (:readers (asdf-2.26::component-in-order-to))
  (:writers ((common-lisp:setf asdf-2.26::component-in-order-to)))))
(:mop-direct asdf-2.26:component :slot
 ((:name asdf-2.26::do-first) (:ordinal 7) (:initargs (:do-first)) (:readers (asdf-2.26::component-do-first))
  (:writers ((common-lisp:setf asdf-2.26::component-do-first)))))
(:mop-direct asdf-2.26:component :slot
 ((:name asdf-2.26::inline-methods) (:ordinal 8) (:readers (asdf-2.26::component-inline-methods))
  (:writers ((common-lisp:setf asdf-2.26::component-inline-methods)))))
(:mop-direct asdf-2.26:component :slot ((:name asdf-2.26::parent) (:ordinal 9) (:initargs (:parent)) (:readers (asdf-2.26:component-parent))))
(:mop-direct asdf-2.26:component :slot ((:name asdf-2.26::relative-pathname) (:ordinal 10) (:initargs (:pathname))))
(:mop-direct asdf-2.26:component :slot ((:name asdf-2.26::absolute-pathname) (:ordinal 11)))
(:mop-direct asdf-2.26:component :slot
 ((:name asdf-2.26::operation-times) (:ordinal 12) (:initform (common-lisp:make-hash-table)) (:readers (asdf-2.26::component-operation-times))
  (:writers ((common-lisp:setf asdf-2.26::component-operation-times)))))
(:mop-direct asdf-2.26:component :slot ((:name asdf-2.26::around-compile) (:ordinal 13) (:initargs (:around-compile))))
(:mop-direct asdf-2.26:component :slot
 ((:name asdf-2.26::%encoding) (:ordinal 14) (:initargs (:encoding)) (:readers (asdf-2.26::%component-encoding))
  (:writers ((common-lisp:setf asdf-2.26::%component-encoding)))))
(:mop-direct asdf-2.26:component :slot
 ((:name asdf-2.26::properties) (:ordinal 15) (:initargs (:properties)) (:readers (asdf-2.26::component-properties))
  (:writers ((common-lisp:setf asdf-2.26::component-properties)))))
(:mop-direct asdf-2.26:source-file :superclass asdf-2.26:component)
(:mop-direct asdf-2.26:static-file :superclass asdf-2.26:source-file)
(:mop-direct asdf-2.26:java-source-file :superclass asdf-2.26:source-file)
(:mop-direct asdf-2.26:c-source-file :superclass asdf-2.26:source-file)
(:mop-direct asdf-2.26:cl-source-file :superclass asdf-2.26:source-file)
(:mop-direct asdf-2.26:source-file :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:source-file :precedance (asdf-2.26:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:source-file :classof clos:standard-class)
(:mop-direct asdf-2.26:source-file :typeof clos:standard-class)
(:mop-direct asdf-2.26:source-file :superclass asdf-2.26:component)
(:mop-direct asdf-2.26:source-file :slot
 ((:name common-lisp:type) (:ordinal 1) (:initargs (:type)) (:readers (asdf-2.26::source-file-explicit-type))
  (:writers ((common-lisp:setf asdf-2.26::source-file-explicit-type)))))
(:mop-direct asdf-2.26:static-file :superclass asdf-2.26:source-file)
(:mop-direct asdf-2.26:doc-file :superclass asdf-2.26:static-file)
(:mop-direct asdf-2.26:static-file :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:static-file :precedance (asdf-2.26:source-file asdf-2.26:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:static-file :classof clos:standard-class)
(:mop-direct asdf-2.26:static-file :typeof clos:standard-class)
(:mop-direct asdf-2.26:static-file :superclass asdf-2.26:source-file)
(:mop-direct asdf-2.26:doc-file :superclass asdf-2.26:static-file)
(:mop-direct asdf-2.26:html-file :superclass asdf-2.26:doc-file)
(:mop-direct asdf-2.26:doc-file :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:doc-file :precedance
 (asdf-2.26:static-file asdf-2.26:source-file asdf-2.26:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:doc-file :classof clos:standard-class)
(:mop-direct asdf-2.26:doc-file :typeof clos:standard-class)
(:mop-direct asdf-2.26:doc-file :superclass asdf-2.26:static-file)
(:mop-direct asdf-2.26:html-file :superclass asdf-2.26:doc-file)
(:mop-direct asdf-2.26:html-file :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:html-file :precedance
 (asdf-2.26:doc-file asdf-2.26:static-file asdf-2.26:source-file asdf-2.26:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:html-file :classof clos:standard-class)
(:mop-direct asdf-2.26:html-file :typeof clos:standard-class)
(:mop-direct asdf-2.26:html-file :superclass asdf-2.26:doc-file)
(:mop-direct asdf-2.26:html-file :slot ((:name common-lisp:type) (:ordinal 1) (:initform "html")))



(:mop-direct asdf-2.26:java-source-file :superclass asdf-2.26:source-file)
(:mop-direct asdf-2.26:java-source-file :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:java-source-file :precedance (asdf-2.26:source-file asdf-2.26:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:java-source-file :classof clos:standard-class)
(:mop-direct asdf-2.26:java-source-file :typeof clos:standard-class)
(:mop-direct asdf-2.26:java-source-file :superclass asdf-2.26:source-file)
(:mop-direct asdf-2.26:java-source-file :slot ((:name common-lisp:type) (:ordinal 1) (:initform "java")))

(:mop-direct asdf-2.26:c-source-file :superclass asdf-2.26:source-file)
(:mop-direct asdf-2.26:c-source-file :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:c-source-file :precedance (asdf-2.26:source-file asdf-2.26:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:c-source-file :classof clos:standard-class)
(:mop-direct asdf-2.26:c-source-file :typeof clos:standard-class)
(:mop-direct asdf-2.26:c-source-file :superclass asdf-2.26:source-file)
(:mop-direct asdf-2.26:c-source-file :slot ((:name common-lisp:type) (:ordinal 1) (:initform "c")))

(:mop-direct asdf-2.26:cl-source-file :superclass asdf-2.26:source-file)
(:mop-direct asdf-2.26:cl-source-file.lsp :superclass asdf-2.26:cl-source-file)
(:mop-direct asdf-2.26:cl-source-file.cl :superclass asdf-2.26:cl-source-file)
(:mop-direct asdf-2.26:cl-source-file :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:cl-source-file :precedance (asdf-2.26:source-file asdf-2.26:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:cl-source-file :classof clos:standard-class)
(:mop-direct asdf-2.26:cl-source-file :typeof clos:standard-class)
(:mop-direct asdf-2.26:cl-source-file :superclass asdf-2.26:source-file)
(:mop-direct asdf-2.26:cl-source-file :slot ((:name common-lisp:type) (:ordinal 1) (:initform "lisp")))
(:mop-direct asdf-2.26:cl-source-file.lsp :superclass asdf-2.26:cl-source-file)
(:mop-direct asdf-2.26:cl-source-file.lsp :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:cl-source-file.lsp :precedance
 (asdf-2.26:cl-source-file asdf-2.26:source-file asdf-2.26:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:cl-source-file.lsp :classof clos:standard-class)
(:mop-direct asdf-2.26:cl-source-file.lsp :typeof clos:standard-class)
(:mop-direct asdf-2.26:cl-source-file.lsp :superclass asdf-2.26:cl-source-file)
(:mop-direct asdf-2.26:cl-source-file.lsp :slot ((:name common-lisp:type) (:ordinal 1) (:initform "lsp")))

(:mop-direct asdf-2.26:cl-source-file.cl :superclass asdf-2.26:cl-source-file)
(:mop-direct asdf-2.26:cl-source-file.cl :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:cl-source-file.cl :precedance
 (asdf-2.26:cl-source-file asdf-2.26:source-file asdf-2.26:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:cl-source-file.cl :classof clos:standard-class)
(:mop-direct asdf-2.26:cl-source-file.cl :typeof clos:standard-class)
(:mop-direct asdf-2.26:cl-source-file.cl :superclass asdf-2.26:cl-source-file)
(:mop-direct asdf-2.26:cl-source-file.cl :slot ((:name common-lisp:type) (:ordinal 1) (:initform "cl")))



(:mop-direct asdf-2.26:module :superclass asdf-2.26:component)
(:mop-direct asdf-2.26:system :superclass asdf-2.26:module)
(:mop-direct asdf-2.26:module :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:module :precedance (asdf-2.26:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:module :classof clos:standard-class)
(:mop-direct asdf-2.26:module :typeof clos:standard-class)
(:mop-direct asdf-2.26:module :superclass asdf-2.26:component)
(:mop-direct asdf-2.26:module :slot
 ((:name asdf-2.26::components) (:ordinal 1) (:initargs (:components)) (:readers (asdf-2.26:module-components))
  (:writers ((common-lisp:setf asdf-2.26:module-components)))))
(:mop-direct asdf-2.26:module :slot
 ((:name asdf-2.26::components-by-name) (:ordinal 2) (:readers (asdf-2.26:module-components-by-name))
  (:writers ((common-lisp:setf asdf-2.26:module-components-by-name)))))
(:mop-direct asdf-2.26:module :slot
 ((:name asdf-2.26::if-component-dep-fails) (:ordinal 3) (:initform :fail) (:initargs (:if-component-dep-fails))
  (:readers (asdf-2.26::module-if-component-dep-fails)) (:writers ((common-lisp:setf asdf-2.26::module-if-component-dep-fails)))))
(:mop-direct asdf-2.26:module :slot
 ((:name asdf-2.26::default-component-class) (:ordinal 4) (:initargs (:default-component-class))
  (:readers (asdf-2.26::module-default-component-class)) (:writers ((common-lisp:setf asdf-2.26::module-default-component-class)))))
(:mop-direct asdf-2.26:system :superclass asdf-2.26:module)
(:mop-direct asdf-2.26:system :superclass asdf-2.26::proto-system)
(:mop-direct asdf-2.26:system :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:system :precedance
 (asdf-2.26:module asdf-2.26:component asdf-2.26::proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:system :classof clos:standard-class)
(:mop-direct asdf-2.26:system :typeof clos:standard-class)
(:mop-direct asdf-2.26:system :superclass asdf-2.26:module)
(:mop-direct asdf-2.26:system :slot
 ((:name asdf-2.26::description) (:ordinal 1) (:initargs (:description)) (:readers (asdf-2.26:system-description))
  (:writers ((common-lisp:setf asdf-2.26:system-description)))))
(:mop-direct asdf-2.26:system :slot
 ((:name asdf-2.26::long-description) (:ordinal 2) (:initargs (:long-description)) (:readers (asdf-2.26:system-long-description))
  (:writers ((common-lisp:setf asdf-2.26:system-long-description)))))
(:mop-direct asdf-2.26:system :slot
 ((:name asdf-2.26::author) (:ordinal 3) (:initargs (:author)) (:readers (asdf-2.26:system-author))
  (:writers ((common-lisp:setf asdf-2.26:system-author)))))
(:mop-direct asdf-2.26:system :slot
 ((:name asdf-2.26::maintainer) (:ordinal 4) (:initargs (:maintainer)) (:readers (asdf-2.26:system-maintainer))
  (:writers ((common-lisp:setf asdf-2.26:system-maintainer)))))
(:mop-direct asdf-2.26:system :slot
 ((:name asdf-2.26::licence) (:ordinal 5) (:initargs (:licence :license)) (:readers (asdf-2.26:system-licence asdf-2.26:system-license))
  (:writers ((common-lisp:setf asdf-2.26:system-licence) (common-lisp:setf asdf-2.26:system-license)))))
(:mop-direct asdf-2.26:system :slot
 ((:name asdf-2.26:source-file) (:ordinal 6) (:initargs (:source-file)) (:readers (asdf-2.26::%system-source-file))
  (:writers (asdf-2.26::%set-system-source-file))))
(:mop-direct asdf-2.26:system :slot
 ((:name asdf-2.26::defsystem-depends-on) (:ordinal 7) (:initargs (:defsystem-depends-on)) (:readers (asdf-2.26::system-defsystem-depends-on))))



(:mop-direct gstream:generic-stream-controller :superclass common-lisp:standard-object)
(:mop-direct gstream:generic-stream-controller :package-name "GSTREAM")
(:mop-direct gstream:generic-stream-controller :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct gstream:generic-stream-controller :classof clos:standard-class)
(:mop-direct gstream:generic-stream-controller :typeof clos:standard-class)
(:mop-direct gstream:generic-stream-controller :superclass common-lisp:standard-object)
(:mop-direct gstream:generic-stream-controller :prototype #<gstream:generic-stream-controller #x000335A62770>)
(:mop-direct common-lisp:condition :superclass common-lisp:standard-object)
(:mop-direct qlqs-http::cbuf-progress :superclass common-lisp:condition)
(:mop-direct asdf/plan:system-out-of-date :superclass common-lisp:condition)
(:mop-direct uiop/configuration:invalid-configuration :superclass common-lisp:condition)
(:mop-direct uiop/lisp-build:compile-condition :superclass common-lisp:condition)
(:mop-direct uiop/version:deprecated-function-condition :superclass common-lisp:condition)
(:mop-direct ql-http::cbuf-progress :superclass common-lisp:condition)
(:mop-direct asdf-2.26::invalid-configuration :superclass common-lisp:condition)
(:mop-direct common-lisp:simple-condition :superclass common-lisp:condition)
(:mop-direct common-lisp:warning :superclass common-lisp:condition)
(:mop-direct common-lisp:serious-condition :superclass common-lisp:condition)
(:mop-direct common-lisp:condition :package-name "COMMON-LISP")
(:mop-direct common-lisp:condition :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:condition :classof clos:standard-class)
(:mop-direct common-lisp:condition :typeof clos:standard-class)
(:mop-direct common-lisp:condition :superclass common-lisp:standard-object)
(:mop-direct qlqs-http::cbuf-progress :superclass common-lisp:condition)
(:mop-direct qlqs-http::cbuf-progress :package-name "QLQS-HTTP")
(:mop-direct qlqs-http::cbuf-progress :precedance (common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-http::cbuf-progress :classof clos:standard-class)
(:mop-direct qlqs-http::cbuf-progress :typeof clos:standard-class)
(:mop-direct qlqs-http::cbuf-progress :superclass common-lisp:condition)
(:mop-direct qlqs-http::cbuf-progress :slot
 ((:name qlqs-http::size) (:ordinal 1) (:initform 0) (:initargs (:size)) (:readers (qlqs-http::cbuf-progress-size))
  (:writers ((common-lisp:setf qlqs-http::cbuf-progress-size)))))
(:mop-direct qlqs-http::cbuf-progress :prototype #<qlqs-http::cbuf-progress #x000335A759F8>)
(:mop-direct asdf/plan:system-out-of-date :superclass common-lisp:condition)
(:mop-direct asdf/plan:system-out-of-date :package-name "ASDF/PLAN")
(:mop-direct asdf/plan:system-out-of-date :precedance (common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/plan:system-out-of-date :classof clos:standard-class)
(:mop-direct asdf/plan:system-out-of-date :typeof clos:standard-class)
(:mop-direct asdf/plan:system-out-of-date :superclass common-lisp:condition)
(:mop-direct asdf/plan:system-out-of-date :slot
 ((:name asdf/component:name) (:ordinal 1) (:initargs (:name)) (:readers (asdf/component:component-name))))
(:mop-direct asdf/plan:system-out-of-date :prototype #<asdf/plan:system-out-of-date #x000335A824D8>)
(:mop-direct uiop/configuration:invalid-configuration :superclass common-lisp:condition)
(:mop-direct asdf/source-registry:invalid-source-registry :superclass uiop/configuration:invalid-configuration)
(:mop-direct asdf/output-translations:invalid-output-translation :superclass uiop/configuration:invalid-configuration)
(:mop-direct uiop/configuration:invalid-configuration :package-name "UIOP/CONFIGURATION")
(:mop-direct uiop/configuration:invalid-configuration :precedance (common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct uiop/configuration:invalid-configuration :classof clos:standard-class)
(:mop-direct uiop/configuration:invalid-configuration :typeof clos:standard-class)
(:mop-direct uiop/configuration:invalid-configuration :superclass common-lisp:condition)
(:mop-direct uiop/configuration:invalid-configuration :slot
 ((:name uiop/configuration::form) (:ordinal 1) (:initargs (:form)) (:readers (uiop/configuration::condition-form))))
(:mop-direct uiop/configuration:invalid-configuration :slot
 ((:name uiop/configuration::location) (:ordinal 2) (:initargs (:location)) (:readers (uiop/configuration::condition-location))))
(:mop-direct uiop/configuration:invalid-configuration :slot
 ((:name common-lisp:format) (:ordinal 3) (:initargs (:format)) (:readers (uiop/configuration::condition-format))))
(:mop-direct uiop/configuration:invalid-configuration :slot
 ((:name uiop/configuration::arguments) (:ordinal 4) (:initargs (:arguments)) (:readers (uiop/configuration::condition-arguments))))
(:mop-direct asdf/source-registry:invalid-source-registry :superclass uiop/configuration:invalid-configuration)
(:mop-direct asdf/source-registry:invalid-source-registry :superclass common-lisp:warning)
(:mop-direct asdf/source-registry:invalid-source-registry :package-name "ASDF/SOURCE-REGISTRY")
(:mop-direct asdf/source-registry:invalid-source-registry :precedance
 (uiop/configuration:invalid-configuration common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/source-registry:invalid-source-registry :classof clos:standard-class)
(:mop-direct asdf/source-registry:invalid-source-registry :typeof clos:standard-class)
(:mop-direct asdf/source-registry:invalid-source-registry :superclass uiop/configuration:invalid-configuration)
(:mop-direct asdf/source-registry:invalid-source-registry :slot
 ((:name common-lisp:format) (:ordinal 1) (:initform (uiop/common-lisp::compatfmt "~@<Invalid source registry ~S~@[ in ~S~]~@{ ~@?~}~@:>"))))
(:mop-direct asdf/source-registry:invalid-source-registry :prototype #<asdf/source-registry:invalid-source-registry #x000335AA1358>)
(:mop-direct asdf/output-translations:invalid-output-translation :superclass uiop/configuration:invalid-configuration)
(:mop-direct asdf/output-translations:invalid-output-translation :superclass common-lisp:warning)
(:mop-direct asdf/output-translations:invalid-output-translation :package-name "ASDF/OUTPUT-TRANSLATIONS")
(:mop-direct asdf/output-translations:invalid-output-translation :precedance
 (uiop/configuration:invalid-configuration common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/output-translations:invalid-output-translation :classof clos:standard-class)
(:mop-direct asdf/output-translations:invalid-output-translation :typeof clos:standard-class)
(:mop-direct asdf/output-translations:invalid-output-translation :superclass uiop/configuration:invalid-configuration)
(:mop-direct asdf/output-translations:invalid-output-translation :slot
 ((:name common-lisp:format) (:ordinal 1)
  (:initform (uiop/common-lisp::compatfmt "~@<Invalid asdf output-translation ~S~@[ in ~S~]~@{ ~@?~}~@:>"))))
(:mop-direct asdf/output-translations:invalid-output-translation :prototype
 #<asdf/output-translations:invalid-output-translation #x000335AB2850>)
(:mop-direct uiop/configuration:invalid-configuration :prototype #<uiop/configuration:invalid-configuration #x000335AB6090>)
(:mop-direct uiop/lisp-build:compile-condition :superclass common-lisp:condition)
(:mop-direct uiop/lisp-build:compile-failed-error :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-failed-warning :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-warned-error :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-warned-warning :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-file-error :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-condition :package-name "UIOP/LISP-BUILD")
(:mop-direct uiop/lisp-build:compile-condition :precedance (common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct uiop/lisp-build:compile-condition :classof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-condition :typeof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-condition :superclass common-lisp:condition)
(:mop-direct uiop/lisp-build:compile-condition :slot
 ((:name uiop/lisp-build::context-format) (:ordinal 1) (:initargs (:context-format))
  (:readers (uiop/lisp-build::compile-condition-context-format))))
(:mop-direct uiop/lisp-build:compile-condition :slot
 ((:name uiop/lisp-build::context-arguments) (:ordinal 2) (:initargs (:context-arguments))
  (:readers (uiop/lisp-build::compile-condition-context-arguments))))
(:mop-direct uiop/lisp-build:compile-condition :slot
 ((:name uiop/lisp-build::description) (:ordinal 3) (:initargs (:description)) (:readers (uiop/lisp-build::compile-condition-description))))
(:mop-direct uiop/lisp-build:compile-failed-error :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-failed-error :superclass common-lisp:error)
(:mop-direct uiop/lisp-build:compile-failed-error :package-name "UIOP/LISP-BUILD")
(:mop-direct uiop/lisp-build:compile-failed-error :precedance
 (uiop/lisp-build:compile-condition common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct uiop/lisp-build:compile-failed-error :classof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-failed-error :typeof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-failed-error :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-failed-error :prototype #<uiop/lisp-build:compile-failed-error #x000335ACC108>)
(:mop-direct uiop/lisp-build:compile-failed-warning :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-failed-warning :superclass common-lisp:warning)
(:mop-direct uiop/lisp-build:compile-failed-warning :package-name "UIOP/LISP-BUILD")
(:mop-direct uiop/lisp-build:compile-failed-warning :precedance
 (uiop/lisp-build:compile-condition common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct uiop/lisp-build:compile-failed-warning :classof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-failed-warning :typeof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-failed-warning :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-failed-warning :prototype #<uiop/lisp-build:compile-failed-warning #x000335AD9B50>)
(:mop-direct uiop/lisp-build:compile-warned-error :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-warned-error :superclass common-lisp:error)
(:mop-direct uiop/lisp-build:compile-warned-error :package-name "UIOP/LISP-BUILD")
(:mop-direct uiop/lisp-build:compile-warned-error :precedance
 (uiop/lisp-build:compile-condition common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct uiop/lisp-build:compile-warned-error :classof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-warned-error :typeof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-warned-error :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-warned-error :prototype #<uiop/lisp-build:compile-warned-error #x000335AE2210>)
(:mop-direct uiop/lisp-build:compile-warned-warning :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-warned-warning :superclass common-lisp:warning)
(:mop-direct uiop/lisp-build:compile-warned-warning :package-name "UIOP/LISP-BUILD")
(:mop-direct uiop/lisp-build:compile-warned-warning :precedance
 (uiop/lisp-build:compile-condition common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct uiop/lisp-build:compile-warned-warning :classof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-warned-warning :typeof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-warned-warning :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-warned-warning :prototype #<uiop/lisp-build:compile-warned-warning #x000335AEAA60>)
(:mop-direct uiop/lisp-build:compile-file-error :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-file-error :superclass common-lisp:error)
(:mop-direct uiop/lisp-build:compile-file-error :package-name "UIOP/LISP-BUILD")
(:mop-direct uiop/lisp-build:compile-file-error :precedance
 (uiop/lisp-build:compile-condition common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct uiop/lisp-build:compile-file-error :classof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-file-error :typeof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-file-error :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-file-error :prototype #<uiop/lisp-build:compile-file-error #x000335AF3120>)
(:mop-direct uiop/lisp-build:compile-condition :prototype #<uiop/lisp-build:compile-condition #x000335AF66A8>)
(:mop-direct uiop/version:deprecated-function-condition :superclass common-lisp:condition)
(:mop-direct uiop/version:deprecated-function-should-be-deleted :superclass uiop/version:deprecated-function-condition)
(:mop-direct uiop/version:deprecated-function-error :superclass uiop/version:deprecated-function-condition)
(:mop-direct uiop/version:deprecated-function-warning :superclass uiop/version:deprecated-function-condition)
(:mop-direct uiop/version:deprecated-function-style-warning :superclass uiop/version:deprecated-function-condition)
(:mop-direct uiop/version:deprecated-function-condition :package-name "UIOP/VERSION")
(:mop-direct uiop/version:deprecated-function-condition :precedance (common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct uiop/version:deprecated-function-condition :classof clos:standard-class)
(:mop-direct uiop/version:deprecated-function-condition :typeof clos:standard-class)
(:mop-direct uiop/version:deprecated-function-condition :superclass common-lisp:condition)
(:mop-direct uiop/version:deprecated-function-condition :slot
 ((:name uiop/version::name) (:ordinal 1) (:initargs (:name)) (:readers (uiop/version:deprecated-function-name))))
(:mop-direct uiop/version:deprecated-function-should-be-deleted :superclass uiop/version:deprecated-function-condition)
(:mop-direct uiop/version:deprecated-function-should-be-deleted :superclass common-lisp:error)
(:mop-direct uiop/version:deprecated-function-should-be-deleted :package-name "UIOP/VERSION")
(:mop-direct uiop/version:deprecated-function-should-be-deleted :precedance
 (uiop/version:deprecated-function-condition common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct uiop/version:deprecated-function-should-be-deleted :classof clos:standard-class)
(:mop-direct uiop/version:deprecated-function-should-be-deleted :typeof clos:standard-class)
(:mop-direct uiop/version:deprecated-function-should-be-deleted :superclass uiop/version:deprecated-function-condition)

(:mop-direct uiop/version:deprecated-function-error :superclass uiop/version:deprecated-function-condition)
(:mop-direct uiop/version:deprecated-function-error :superclass common-lisp:error)
(:mop-direct uiop/version:deprecated-function-error :package-name "UIOP/VERSION")
(:mop-direct uiop/version:deprecated-function-error :precedance
 (uiop/version:deprecated-function-condition common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct uiop/version:deprecated-function-error :classof clos:standard-class)
(:mop-direct uiop/version:deprecated-function-error :typeof clos:standard-class)
(:mop-direct uiop/version:deprecated-function-error :superclass uiop/version:deprecated-function-condition)

(:mop-direct uiop/version:deprecated-function-warning :superclass uiop/version:deprecated-function-condition)
(:mop-direct uiop/version:deprecated-function-warning :superclass common-lisp:warning)
(:mop-direct uiop/version:deprecated-function-warning :package-name "UIOP/VERSION")
(:mop-direct uiop/version:deprecated-function-warning :precedance
 (uiop/version:deprecated-function-condition common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct uiop/version:deprecated-function-warning :classof clos:standard-class)
(:mop-direct uiop/version:deprecated-function-warning :typeof clos:standard-class)
(:mop-direct uiop/version:deprecated-function-warning :superclass uiop/version:deprecated-function-condition)

(:mop-direct uiop/version:deprecated-function-style-warning :superclass uiop/version:deprecated-function-condition)
(:mop-direct uiop/version:deprecated-function-style-warning :superclass common-lisp:style-warning)
(:mop-direct uiop/version:deprecated-function-style-warning :package-name "UIOP/VERSION")
(:mop-direct uiop/version:deprecated-function-style-warning :precedance
 (uiop/version:deprecated-function-condition common-lisp:style-warning common-lisp:warning common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct uiop/version:deprecated-function-style-warning :classof clos:standard-class)
(:mop-direct uiop/version:deprecated-function-style-warning :typeof clos:standard-class)
(:mop-direct uiop/version:deprecated-function-style-warning :superclass uiop/version:deprecated-function-condition)


(:mop-direct ql-http::cbuf-progress :superclass common-lisp:condition)
(:mop-direct ql-http::cbuf-progress :package-name "QL-HTTP")
(:mop-direct ql-http::cbuf-progress :precedance (common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ql-http::cbuf-progress :classof clos:standard-class)
(:mop-direct ql-http::cbuf-progress :typeof clos:standard-class)
(:mop-direct ql-http::cbuf-progress :superclass common-lisp:condition)
(:mop-direct ql-http::cbuf-progress :slot
 ((:name ql-http::size) (:ordinal 1) (:initform 0) (:initargs (:size)) (:readers (ql-http::cbuf-progress-size))
  (:writers ((common-lisp:setf ql-http::cbuf-progress-size)))))
(:mop-direct ql-http::cbuf-progress :prototype #<ql-http::cbuf-progress #x000335990FE0>)
(:mop-direct asdf-2.26::invalid-configuration :superclass common-lisp:condition)
(:mop-direct asdf-2.26::invalid-output-translation :superclass asdf-2.26::invalid-configuration)
(:mop-direct asdf-2.26::invalid-source-registry :superclass asdf-2.26::invalid-configuration)
(:mop-direct asdf-2.26::invalid-configuration :package-name "ASDF-2.26")
(:mop-direct asdf-2.26::invalid-configuration :precedance (common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26::invalid-configuration :classof clos:standard-class)
(:mop-direct asdf-2.26::invalid-configuration :typeof clos:standard-class)
(:mop-direct asdf-2.26::invalid-configuration :superclass common-lisp:condition)
(:mop-direct asdf-2.26::invalid-configuration :slot
 ((:name asdf-2.26::form) (:ordinal 1) (:initargs (:form)) (:readers (asdf-2.26::condition-form))))
(:mop-direct asdf-2.26::invalid-configuration :slot
 ((:name asdf-2.26::location) (:ordinal 2) (:initargs (:location)) (:readers (asdf-2.26::condition-location))))
(:mop-direct asdf-2.26::invalid-configuration :slot
 ((:name common-lisp:format) (:ordinal 3) (:initargs (:format)) (:readers (asdf-2.26::condition-format))))
(:mop-direct asdf-2.26::invalid-configuration :slot
 ((:name asdf-2.26::arguments) (:ordinal 4) (:initargs (:arguments)) (:readers (asdf-2.26::condition-arguments))))
(:mop-direct asdf-2.26::invalid-output-translation :superclass asdf-2.26::invalid-configuration)
(:mop-direct asdf-2.26::invalid-output-translation :superclass common-lisp:warning)
(:mop-direct asdf-2.26::invalid-output-translation :package-name "ASDF-2.26")
(:mop-direct asdf-2.26::invalid-output-translation :precedance
 (asdf-2.26::invalid-configuration common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26::invalid-output-translation :classof clos:standard-class)
(:mop-direct asdf-2.26::invalid-output-translation :typeof clos:standard-class)
(:mop-direct asdf-2.26::invalid-output-translation :superclass asdf-2.26::invalid-configuration)
(:mop-direct asdf-2.26::invalid-output-translation :slot
 ((:name common-lisp:format) (:ordinal 1) (:initform (asdf-2.26::compatfmt "~@<Invalid asdf output-translation ~S~@[ in ~S~]~@{ ~@?~}~@:>"))))
(:mop-direct asdf-2.26::invalid-output-translation :prototype #<asdf-2.26::invalid-output-translation #x0003359A89C0>)
(:mop-direct asdf-2.26::invalid-source-registry :superclass asdf-2.26::invalid-configuration)
(:mop-direct asdf-2.26::invalid-source-registry :superclass common-lisp:warning)
(:mop-direct asdf-2.26::invalid-source-registry :package-name "ASDF-2.26")
(:mop-direct asdf-2.26::invalid-source-registry :precedance
 (asdf-2.26::invalid-configuration common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26::invalid-source-registry :classof clos:standard-class)
(:mop-direct asdf-2.26::invalid-source-registry :typeof clos:standard-class)
(:mop-direct asdf-2.26::invalid-source-registry :superclass asdf-2.26::invalid-configuration)
(:mop-direct asdf-2.26::invalid-source-registry :slot
 ((:name common-lisp:format) (:ordinal 1) (:initform (asdf-2.26::compatfmt "~@<Invalid source registry ~S~@[ in ~S~]~@{ ~@?~}~@:>"))))
(:mop-direct asdf-2.26::invalid-source-registry :prototype #<asdf-2.26::invalid-source-registry #x0003359B8368>)
(:mop-direct asdf-2.26::invalid-configuration :prototype #<asdf-2.26::invalid-configuration #x0003359BB180>)
(:mop-direct common-lisp:simple-condition :superclass common-lisp:condition)
(:mop-direct uiop/utility:simple-style-warning :superclass common-lisp:simple-condition)
(:mop-direct system::simple-interrupt-condition :superclass common-lisp:simple-condition)
(:mop-direct system::simple-storage-condition :superclass common-lisp:simple-condition)
(:mop-direct system::simple-serious-condition :superclass common-lisp:simple-condition)
(:mop-direct clos::simple-gf-replacing-method-warning :superclass common-lisp:simple-condition)
(:mop-direct clos::simple-gf-already-called-warning :superclass common-lisp:simple-condition)
(:mop-direct clos::simple-clos-warning :superclass common-lisp:simple-condition)
(:mop-direct system::simple-style-warning :superclass common-lisp:simple-condition)
(:mop-direct common-lisp:simple-warning :superclass common-lisp:simple-condition)
(:mop-direct common-lisp:simple-type-error :superclass common-lisp:simple-condition)
(:mop-direct common-lisp:simple-error :superclass common-lisp:simple-condition)
(:mop-direct common-lisp:simple-condition :package-name "COMMON-LISP")
(:mop-direct common-lisp:simple-condition :precedance (common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:simple-condition :classof clos:standard-class)
(:mop-direct common-lisp:simple-condition :typeof clos:standard-class)
(:mop-direct common-lisp:simple-condition :superclass common-lisp:condition)
(:mop-direct common-lisp:simple-condition :slot
 ((:name system::$format-control) (:ordinal 1) (:initargs (:format-control))
  (:readers (ext:simple-condition-format-string common-lisp:simple-condition-format-control))))
(:mop-direct common-lisp:simple-condition :slot
 ((:name system::$format-arguments) (:ordinal 2) (:initargs (:format-arguments)) (:readers (common-lisp:simple-condition-format-arguments))))
(:mop-direct uiop/utility:simple-style-warning :superclass common-lisp:simple-condition)
(:mop-direct uiop/utility:simple-style-warning :superclass common-lisp:style-warning)
(:mop-direct uiop/utility:simple-style-warning :package-name "UIOP/UTILITY")
(:mop-direct uiop/utility:simple-style-warning :precedance
 (common-lisp:simple-condition common-lisp:style-warning common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct uiop/utility:simple-style-warning :classof clos:standard-class)
(:mop-direct uiop/utility:simple-style-warning :typeof clos:standard-class)
(:mop-direct uiop/utility:simple-style-warning :superclass common-lisp:simple-condition)
(:mop-direct uiop/utility:simple-style-warning :prototype #<uiop/utility:simple-style-warning #x0003359D2050>)
(:mop-direct system::simple-interrupt-condition :superclass common-lisp:simple-condition)
(:mop-direct system::simple-interrupt-condition :superclass system::interrupt-condition)
(:mop-direct system::simple-interrupt-condition :package-name "SYSTEM")
(:mop-direct system::simple-interrupt-condition :precedance
 (common-lisp:simple-condition system::interrupt-condition common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct system::simple-interrupt-condition :classof clos:standard-class)
(:mop-direct system::simple-interrupt-condition :typeof clos:standard-class)
(:mop-direct system::simple-interrupt-condition :superclass common-lisp:simple-condition)
(:mop-direct system::simple-interrupt-condition :prototype #<system::simple-interrupt-condition #x0003359E1A60>)
(:mop-direct system::simple-storage-condition :superclass common-lisp:simple-condition)
(:mop-direct system::simple-storage-condition :superclass common-lisp:storage-condition)
(:mop-direct system::simple-storage-condition :package-name "SYSTEM")
(:mop-direct system::simple-storage-condition :precedance
 (common-lisp:simple-condition common-lisp:storage-condition common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct system::simple-storage-condition :classof clos:standard-class)
(:mop-direct system::simple-storage-condition :typeof clos:standard-class)
(:mop-direct system::simple-storage-condition :superclass common-lisp:simple-condition)
(:mop-direct system::simple-storage-condition :prototype #<system::simple-storage-condition #x0003359E99C0>)
(:mop-direct system::simple-serious-condition :superclass common-lisp:simple-condition)
(:mop-direct system::simple-serious-condition :superclass common-lisp:serious-condition)
(:mop-direct system::simple-serious-condition :package-name "SYSTEM")
(:mop-direct system::simple-serious-condition :precedance
 (common-lisp:simple-condition common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-serious-condition :classof clos:standard-class)
(:mop-direct system::simple-serious-condition :typeof clos:standard-class)
(:mop-direct system::simple-serious-condition :superclass common-lisp:simple-condition)
(:mop-direct system::simple-serious-condition :prototype #<system::simple-serious-condition #x0003359F1928>)
(:mop-direct clos::simple-gf-replacing-method-warning :superclass common-lisp:simple-condition)
(:mop-direct clos::simple-gf-replacing-method-warning :superclass clos:gf-replacing-method-warning)
(:mop-direct clos::simple-gf-replacing-method-warning :package-name "CLOS")
(:mop-direct clos::simple-gf-replacing-method-warning :precedance
 (common-lisp:simple-condition clos:gf-replacing-method-warning clos:clos-warning common-lisp:warning common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos::simple-gf-replacing-method-warning :classof clos:standard-class)
(:mop-direct clos::simple-gf-replacing-method-warning :typeof clos:standard-class)
(:mop-direct clos::simple-gf-replacing-method-warning :superclass common-lisp:simple-condition)
(:mop-direct clos::simple-gf-replacing-method-warning :prototype #<clos::simple-gf-replacing-method-warning #x0003359F97B0>)
(:mop-direct clos::simple-gf-already-called-warning :superclass common-lisp:simple-condition)
(:mop-direct clos::simple-gf-already-called-warning :superclass clos:gf-already-called-warning)
(:mop-direct clos::simple-gf-already-called-warning :package-name "CLOS")
(:mop-direct clos::simple-gf-already-called-warning :precedance
 (common-lisp:simple-condition clos:gf-already-called-warning clos:clos-warning common-lisp:warning common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos::simple-gf-already-called-warning :classof clos:standard-class)
(:mop-direct clos::simple-gf-already-called-warning :typeof clos:standard-class)
(:mop-direct clos::simple-gf-already-called-warning :superclass common-lisp:simple-condition)
(:mop-direct clos::simple-gf-already-called-warning :prototype #<clos::simple-gf-already-called-warning #x000335A017D0>)
(:mop-direct clos::simple-clos-warning :superclass common-lisp:simple-condition)
(:mop-direct clos::simple-clos-warning :superclass clos:clos-warning)
(:mop-direct clos::simple-clos-warning :package-name "CLOS")
(:mop-direct clos::simple-clos-warning :precedance
 (common-lisp:simple-condition clos:clos-warning common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct clos::simple-clos-warning :classof clos:standard-class)
(:mop-direct clos::simple-clos-warning :typeof clos:standard-class)
(:mop-direct clos::simple-clos-warning :superclass common-lisp:simple-condition)
(:mop-direct clos::simple-clos-warning :prototype #<clos::simple-clos-warning #x000335A098A8>)
(:mop-direct system::simple-style-warning :superclass common-lisp:simple-condition)
(:mop-direct system::simple-style-warning :superclass common-lisp:style-warning)
(:mop-direct system::simple-style-warning :package-name "SYSTEM")
(:mop-direct system::simple-style-warning :precedance
 (common-lisp:simple-condition common-lisp:style-warning common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-style-warning :classof clos:standard-class)
(:mop-direct system::simple-style-warning :typeof clos:standard-class)
(:mop-direct system::simple-style-warning :superclass common-lisp:simple-condition)
(:mop-direct system::simple-style-warning :prototype #<system::simple-style-warning #x000335A12CD8>)
(:mop-direct common-lisp:simple-warning :superclass common-lisp:simple-condition)
(:mop-direct common-lisp:simple-warning :superclass common-lisp:warning)
(:mop-direct asdf/action:operation-definition-warning :superclass common-lisp:simple-warning)
(:mop-direct common-lisp:simple-warning :package-name "COMMON-LISP")
(:mop-direct common-lisp:simple-warning :precedance
 (common-lisp:simple-condition common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:simple-warning :classof clos:standard-class)
(:mop-direct common-lisp:simple-warning :typeof clos:standard-class)
(:mop-direct common-lisp:simple-warning :superclass common-lisp:simple-condition)
(:mop-direct asdf/action:operation-definition-warning :superclass common-lisp:simple-warning)
(:mop-direct asdf/action:operation-definition-warning :package-name "ASDF/ACTION")
(:mop-direct asdf/action:operation-definition-warning :precedance
 (common-lisp:simple-warning common-lisp:simple-condition common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/action:operation-definition-warning :classof clos:standard-class)
(:mop-direct asdf/action:operation-definition-warning :typeof clos:standard-class)
(:mop-direct asdf/action:operation-definition-warning :superclass common-lisp:simple-warning)
(:mop-direct asdf/action:operation-definition-warning :prototype #<asdf/action:operation-definition-warning #x000335A1FD78>)
(:mop-direct common-lisp:simple-warning :prototype #<common-lisp:simple-warning #x000335A22B80>)
(:mop-direct common-lisp:simple-type-error :superclass common-lisp:simple-condition)
(:mop-direct common-lisp:simple-type-error :superclass common-lisp:type-error)
(:mop-direct clos:method-call-type-error :superclass common-lisp:simple-type-error)
(:mop-direct common-lisp:simple-type-error :package-name "COMMON-LISP")
(:mop-direct common-lisp:simple-type-error :precedance
 (common-lisp:simple-condition common-lisp:type-error common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:simple-type-error :classof clos:standard-class)
(:mop-direct common-lisp:simple-type-error :typeof clos:standard-class)
(:mop-direct common-lisp:simple-type-error :superclass common-lisp:simple-condition)
(:mop-direct clos:method-call-type-error :superclass common-lisp:simple-type-error)
(:mop-direct clos:method-call-type-error :superclass clos:method-call-error)
(:mop-direct clos:method-call-type-error :package-name "CLOS")
(:mop-direct clos:method-call-type-error :precedance
 (common-lisp:simple-type-error clos:method-call-error common-lisp:simple-error common-lisp:simple-condition common-lisp:type-error
  common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct clos:method-call-type-error :classof clos:standard-class)
(:mop-direct clos:method-call-type-error :typeof clos:standard-class)
(:mop-direct clos:method-call-type-error :superclass common-lisp:simple-type-error)
(:mop-direct clos:method-call-type-error :prototype #<clos:method-call-type-error #x000335A30A80>)
(:mop-direct common-lisp:simple-type-error :prototype #<common-lisp:simple-type-error #x000335A333E0>)
(:mop-direct common-lisp:simple-error :superclass common-lisp:simple-condition)
(:mop-direct common-lisp:simple-error :superclass common-lisp:error)
(:mop-direct system::simple-unbound-slot :superclass common-lisp:simple-error)
(:mop-direct system::simple-undefined-function :superclass common-lisp:simple-error)
(:mop-direct system::simple-unbound-variable :superclass common-lisp:simple-error)
(:mop-direct system::simple-cell-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-floating-point-underflow :superclass common-lisp:simple-error)
(:mop-direct system::simple-floating-point-overflow :superclass common-lisp:simple-error)
(:mop-direct system::simple-division-by-zero :superclass common-lisp:simple-error)
(:mop-direct system::simple-arithmetic-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-control-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-source-program-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-program-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-keyword-error :superclass common-lisp:simple-error)
(:mop-direct ext:simple-charset-type-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-argument-list-dotted :superclass common-lisp:simple-error)
(:mop-direct system::simple-package-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-print-not-readable :superclass common-lisp:simple-error)
(:mop-direct system::simple-parse-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-stream-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-end-of-file :superclass common-lisp:simple-error)
(:mop-direct system::simple-reader-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-file-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-os-error :superclass common-lisp:simple-error)
(:mop-direct clos:method-call-error :superclass common-lisp:simple-error)
(:mop-direct clos::simple-missing-load-form :superclass common-lisp:simple-error)
(:mop-direct ql-gunzipper::decompression-error :superclass common-lisp:simple-error)
(:mop-direct asdf/action:operation-definition-error :superclass common-lisp:simple-error)
(:mop-direct common-lisp:simple-error :package-name "COMMON-LISP")
(:mop-direct common-lisp:simple-error :precedance
 (common-lisp:simple-condition common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:simple-error :classof clos:standard-class)
(:mop-direct common-lisp:simple-error :typeof clos:standard-class)
(:mop-direct common-lisp:simple-error :superclass common-lisp:simple-condition)
(:mop-direct system::simple-unbound-slot :superclass common-lisp:simple-error)
(:mop-direct system::simple-unbound-slot :superclass common-lisp:unbound-slot)
(:mop-direct system::simple-unbound-slot :package-name "SYSTEM")
(:mop-direct system::simple-unbound-slot :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:unbound-slot common-lisp:cell-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-unbound-slot :classof clos:standard-class)
(:mop-direct system::simple-unbound-slot :typeof clos:standard-class)
(:mop-direct system::simple-unbound-slot :superclass common-lisp:simple-error)
(:mop-direct system::simple-unbound-slot :prototype #<system::simple-unbound-slot #x000335A4FEC8>)
(:mop-direct system::simple-undefined-function :superclass common-lisp:simple-error)
(:mop-direct system::simple-undefined-function :superclass common-lisp:undefined-function)
(:mop-direct system::simple-undefined-function :package-name "SYSTEM")
(:mop-direct system::simple-undefined-function :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:undefined-function common-lisp:cell-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-undefined-function :classof clos:standard-class)
(:mop-direct system::simple-undefined-function :typeof clos:standard-class)
(:mop-direct system::simple-undefined-function :superclass common-lisp:simple-error)
(:mop-direct system::simple-undefined-function :prototype #<system::simple-undefined-function #x000335A57E00>)
(:mop-direct system::simple-unbound-variable :superclass common-lisp:simple-error)
(:mop-direct system::simple-unbound-variable :superclass common-lisp:unbound-variable)
(:mop-direct system::simple-unbound-variable :package-name "SYSTEM")
(:mop-direct system::simple-unbound-variable :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:unbound-variable common-lisp:cell-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-unbound-variable :classof clos:standard-class)
(:mop-direct system::simple-unbound-variable :typeof clos:standard-class)
(:mop-direct system::simple-unbound-variable :superclass common-lisp:simple-error)
(:mop-direct system::simple-unbound-variable :prototype #<system::simple-unbound-variable #x000335A601F8>)
(:mop-direct system::simple-cell-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-cell-error :superclass common-lisp:cell-error)
(:mop-direct system::simple-cell-error :package-name "SYSTEM")
(:mop-direct system::simple-cell-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:cell-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-cell-error :classof clos:standard-class)
(:mop-direct system::simple-cell-error :typeof clos:standard-class)
(:mop-direct system::simple-cell-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-cell-error :prototype #<system::simple-cell-error #x000335A681A8>)
(:mop-direct system::simple-floating-point-underflow :superclass common-lisp:simple-error)
(:mop-direct system::simple-floating-point-underflow :superclass common-lisp:floating-point-underflow)
(:mop-direct system::simple-floating-point-underflow :package-name "SYSTEM")
(:mop-direct system::simple-floating-point-underflow :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:floating-point-underflow common-lisp:arithmetic-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-floating-point-underflow :classof clos:standard-class)
(:mop-direct system::simple-floating-point-underflow :typeof clos:standard-class)
(:mop-direct system::simple-floating-point-underflow :superclass common-lisp:simple-error)
(:mop-direct system::simple-floating-point-underflow :prototype #<system::simple-floating-point-underflow #x000335A70438>)
(:mop-direct system::simple-floating-point-overflow :superclass common-lisp:simple-error)
(:mop-direct system::simple-floating-point-overflow :superclass common-lisp:floating-point-overflow)
(:mop-direct system::simple-floating-point-overflow :package-name "SYSTEM")
(:mop-direct system::simple-floating-point-overflow :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:floating-point-overflow common-lisp:arithmetic-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-floating-point-overflow :classof clos:standard-class)
(:mop-direct system::simple-floating-point-overflow :typeof clos:standard-class)
(:mop-direct system::simple-floating-point-overflow :superclass common-lisp:simple-error)
(:mop-direct system::simple-floating-point-overflow :prototype #<system::simple-floating-point-overflow #x000335A78870>)
(:mop-direct system::simple-division-by-zero :superclass common-lisp:simple-error)
(:mop-direct system::simple-division-by-zero :superclass common-lisp:division-by-zero)
(:mop-direct system::simple-division-by-zero :package-name "SYSTEM")
(:mop-direct system::simple-division-by-zero :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:division-by-zero common-lisp:arithmetic-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-division-by-zero :classof clos:standard-class)
(:mop-direct system::simple-division-by-zero :typeof clos:standard-class)
(:mop-direct system::simple-division-by-zero :superclass common-lisp:simple-error)
(:mop-direct system::simple-division-by-zero :prototype #<system::simple-division-by-zero #x000335A80C88>)
(:mop-direct system::simple-arithmetic-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-arithmetic-error :superclass common-lisp:arithmetic-error)
(:mop-direct system::simple-arithmetic-error :package-name "SYSTEM")
(:mop-direct system::simple-arithmetic-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:arithmetic-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-arithmetic-error :classof clos:standard-class)
(:mop-direct system::simple-arithmetic-error :typeof clos:standard-class)
(:mop-direct system::simple-arithmetic-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-arithmetic-error :prototype #<system::simple-arithmetic-error #x000335A88DF8>)
(:mop-direct system::simple-control-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-control-error :superclass common-lisp:control-error)
(:mop-direct system::simple-control-error :package-name "SYSTEM")
(:mop-direct system::simple-control-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:control-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-control-error :classof clos:standard-class)
(:mop-direct system::simple-control-error :typeof clos:standard-class)
(:mop-direct system::simple-control-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-control-error :prototype #<system::simple-control-error #x000335A90F58>)
(:mop-direct system::simple-source-program-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-source-program-error :superclass ext:source-program-error)
(:mop-direct system::simple-source-program-error :package-name "SYSTEM")
(:mop-direct system::simple-source-program-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition ext:source-program-error common-lisp:program-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-source-program-error :classof clos:standard-class)
(:mop-direct system::simple-source-program-error :typeof clos:standard-class)
(:mop-direct system::simple-source-program-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-source-program-error :prototype #<system::simple-source-program-error #x000335A98E78>)
(:mop-direct system::simple-program-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-program-error :superclass common-lisp:program-error)
(:mop-direct system::simple-program-error :package-name "SYSTEM")
(:mop-direct system::simple-program-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:program-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-program-error :classof clos:standard-class)
(:mop-direct system::simple-program-error :typeof clos:standard-class)
(:mop-direct system::simple-program-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-program-error :prototype #<system::simple-program-error #x000335AA1178>)
(:mop-direct system::simple-keyword-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-keyword-error :superclass system::keyword-error)
(:mop-direct system::simple-keyword-error :package-name "SYSTEM")
(:mop-direct system::simple-keyword-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition system::keyword-error common-lisp:program-error common-lisp:type-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-keyword-error :classof clos:standard-class)
(:mop-direct system::simple-keyword-error :typeof clos:standard-class)
(:mop-direct system::simple-keyword-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-keyword-error :prototype #<system::simple-keyword-error #x000335AA91F8>)
(:mop-direct ext:simple-charset-type-error :superclass common-lisp:simple-error)
(:mop-direct ext:simple-charset-type-error :superclass system::charset-type-error)
(:mop-direct ext:simple-charset-type-error :package-name "EXT")
(:mop-direct ext:simple-charset-type-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition system::charset-type-error common-lisp:type-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ext:simple-charset-type-error :classof clos:standard-class)
(:mop-direct ext:simple-charset-type-error :typeof clos:standard-class)
(:mop-direct ext:simple-charset-type-error :superclass common-lisp:simple-error)
(:mop-direct ext:simple-charset-type-error :prototype #<ext:simple-charset-type-error #x000335AB1120>)
(:mop-direct system::simple-argument-list-dotted :superclass common-lisp:simple-error)
(:mop-direct system::simple-argument-list-dotted :superclass system::argument-list-dotted)
(:mop-direct system::simple-argument-list-dotted :package-name "SYSTEM")
(:mop-direct system::simple-argument-list-dotted :precedance
 (common-lisp:simple-error common-lisp:simple-condition system::argument-list-dotted common-lisp:program-error common-lisp:type-error
  common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-argument-list-dotted :classof clos:standard-class)
(:mop-direct system::simple-argument-list-dotted :typeof clos:standard-class)
(:mop-direct system::simple-argument-list-dotted :superclass common-lisp:simple-error)
(:mop-direct system::simple-argument-list-dotted :prototype #<system::simple-argument-list-dotted #x000335AB97E0>)
(:mop-direct system::simple-package-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-package-error :superclass common-lisp:package-error)
(:mop-direct system::simple-package-error :package-name "SYSTEM")
(:mop-direct system::simple-package-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:package-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-package-error :classof clos:standard-class)
(:mop-direct system::simple-package-error :typeof clos:standard-class)
(:mop-direct system::simple-package-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-package-error :prototype #<system::simple-package-error #x000335AC1AE0>)
(:mop-direct system::simple-print-not-readable :superclass common-lisp:simple-error)
(:mop-direct system::simple-print-not-readable :superclass common-lisp:print-not-readable)
(:mop-direct system::simple-print-not-readable :package-name "SYSTEM")
(:mop-direct system::simple-print-not-readable :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:print-not-readable common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-print-not-readable :classof clos:standard-class)
(:mop-direct system::simple-print-not-readable :typeof clos:standard-class)
(:mop-direct system::simple-print-not-readable :superclass common-lisp:simple-error)
(:mop-direct system::simple-print-not-readable :prototype #<system::simple-print-not-readable #x000335AC9920>)
(:mop-direct system::simple-parse-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-parse-error :superclass common-lisp:parse-error)
(:mop-direct system::simple-parse-error :package-name "SYSTEM")
(:mop-direct system::simple-parse-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:parse-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-parse-error :classof clos:standard-class)
(:mop-direct system::simple-parse-error :typeof clos:standard-class)
(:mop-direct system::simple-parse-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-parse-error :prototype #<system::simple-parse-error #x000335AD1C10>)
(:mop-direct system::simple-stream-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-stream-error :superclass common-lisp:stream-error)
(:mop-direct system::simple-stream-error :package-name "SYSTEM")
(:mop-direct system::simple-stream-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:stream-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-stream-error :classof clos:standard-class)
(:mop-direct system::simple-stream-error :typeof clos:standard-class)
(:mop-direct system::simple-stream-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-stream-error :prototype #<system::simple-stream-error #x000335AD9A30>)
(:mop-direct system::simple-end-of-file :superclass common-lisp:simple-error)
(:mop-direct system::simple-end-of-file :superclass common-lisp:end-of-file)
(:mop-direct system::simple-end-of-file :package-name "SYSTEM")
(:mop-direct system::simple-end-of-file :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:end-of-file common-lisp:stream-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-end-of-file :classof clos:standard-class)
(:mop-direct system::simple-end-of-file :typeof clos:standard-class)
(:mop-direct system::simple-end-of-file :superclass common-lisp:simple-error)
(:mop-direct system::simple-end-of-file :prototype #<system::simple-end-of-file #x000335AE1950>)
(:mop-direct system::simple-reader-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-reader-error :superclass common-lisp:reader-error)
(:mop-direct system::simple-reader-error :package-name "SYSTEM")
(:mop-direct system::simple-reader-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:reader-error common-lisp:parse-error common-lisp:stream-error
  common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-reader-error :classof clos:standard-class)
(:mop-direct system::simple-reader-error :typeof clos:standard-class)
(:mop-direct system::simple-reader-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-reader-error :prototype #<system::simple-reader-error #x000335AE9CC8>)
(:mop-direct system::simple-file-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-file-error :superclass common-lisp:file-error)
(:mop-direct system::simple-file-error :package-name "SYSTEM")
(:mop-direct system::simple-file-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:file-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-file-error :classof clos:standard-class)
(:mop-direct system::simple-file-error :typeof clos:standard-class)
(:mop-direct system::simple-file-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-file-error :prototype #<system::simple-file-error #x000335AF1948>)
(:mop-direct system::simple-os-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-os-error :superclass ext:os-error)
(:mop-direct system::simple-os-error :package-name "SYSTEM")
(:mop-direct system::simple-os-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition ext:os-error common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-os-error :classof clos:standard-class)
(:mop-direct system::simple-os-error :typeof clos:standard-class)
(:mop-direct system::simple-os-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-os-error :prototype #<system::simple-os-error #x000335AF9458>)
(:mop-direct clos:method-call-error :superclass common-lisp:simple-error)
(:mop-direct clos:method-call-type-error :superclass clos:method-call-error)
(:mop-direct clos:method-call-error :package-name "CLOS")
(:mop-direct clos:method-call-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos:method-call-error :classof clos:standard-class)
(:mop-direct clos:method-call-error :typeof clos:standard-class)
(:mop-direct clos:method-call-error :superclass common-lisp:simple-error)
(:mop-direct clos:method-call-error :slot
 ((:name system::$gf) (:ordinal 1) (:initargs (:generic-function)) (:readers (clos:method-call-error-generic-function))))
(:mop-direct clos:method-call-error :slot
 ((:name system::$method) (:ordinal 2) (:initargs (:method)) (:readers (clos:method-call-error-method))))
(:mop-direct clos:method-call-error :slot
 ((:name system::$args) (:ordinal 3) (:initargs (:argument-list)) (:readers (clos:method-call-error-argument-list))))
(:mop-direct clos:method-call-type-error :superclass common-lisp:simple-type-error)
(:mop-direct clos:method-call-type-error :superclass clos:method-call-error)
(:mop-direct clos:method-call-type-error :package-name "CLOS")
(:mop-direct clos:method-call-type-error :precedance
 (common-lisp:simple-type-error clos:method-call-error common-lisp:simple-error common-lisp:simple-condition common-lisp:type-error
  common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct clos:method-call-type-error :classof clos:standard-class)
(:mop-direct clos:method-call-type-error :typeof clos:standard-class)
(:mop-direct clos:method-call-type-error :superclass clos:method-call-error)
(:mop-direct clos:method-call-type-error :prototype #<clos:method-call-type-error #x0003359630F0>)
(:mop-direct clos:method-call-error :prototype #<clos:method-call-error #x000335976E30>)
(:mop-direct clos::simple-missing-load-form :superclass common-lisp:simple-error)
(:mop-direct clos::simple-missing-load-form :superclass clos::missing-load-form)
(:mop-direct clos::simple-missing-load-form :package-name "CLOS")
(:mop-direct clos::simple-missing-load-form :precedance
 (common-lisp:simple-error common-lisp:simple-condition clos::missing-load-form common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct clos::simple-missing-load-form :classof clos:standard-class)
(:mop-direct clos::simple-missing-load-form :typeof clos:standard-class)
(:mop-direct clos::simple-missing-load-form :superclass common-lisp:simple-error)
(:mop-direct clos::simple-missing-load-form :prototype #<clos::simple-missing-load-form #x00033597EC60>)
(:mop-direct ql-gunzipper::decompression-error :superclass common-lisp:simple-error)
(:mop-direct ql-gunzipper::gzip-decompression-error :superclass ql-gunzipper::decompression-error)
(:mop-direct ql-gunzipper::zlib-decompression-error :superclass ql-gunzipper::decompression-error)
(:mop-direct ql-gunzipper::deflate-decompression-error :superclass ql-gunzipper::decompression-error)
(:mop-direct ql-gunzipper::decompression-error :package-name "QL-GUNZIPPER")
(:mop-direct ql-gunzipper::decompression-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct ql-gunzipper::decompression-error :classof clos:standard-class)
(:mop-direct ql-gunzipper::decompression-error :typeof clos:standard-class)
(:mop-direct ql-gunzipper::decompression-error :superclass common-lisp:simple-error)
(:mop-direct ql-gunzipper::gzip-decompression-error :superclass ql-gunzipper::decompression-error)
(:mop-direct ql-gunzipper::gzip-decompression-error :package-name "QL-GUNZIPPER")
(:mop-direct ql-gunzipper::gzip-decompression-error :precedance
 (ql-gunzipper::decompression-error common-lisp:simple-error common-lisp:simple-condition common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ql-gunzipper::gzip-decompression-error :classof clos:standard-class)
(:mop-direct ql-gunzipper::gzip-decompression-error :typeof clos:standard-class)
(:mop-direct ql-gunzipper::gzip-decompression-error :superclass ql-gunzipper::decompression-error)
(:mop-direct ql-gunzipper::gzip-decompression-error :prototype #<ql-gunzipper::gzip-decompression-error #x00033598CC98>)
(:mop-direct ql-gunzipper::zlib-decompression-error :superclass ql-gunzipper::decompression-error)
(:mop-direct ql-gunzipper::zlib-decompression-error :package-name "QL-GUNZIPPER")
(:mop-direct ql-gunzipper::zlib-decompression-error :precedance
 (ql-gunzipper::decompression-error common-lisp:simple-error common-lisp:simple-condition common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ql-gunzipper::zlib-decompression-error :classof clos:standard-class)
(:mop-direct ql-gunzipper::zlib-decompression-error :typeof clos:standard-class)
(:mop-direct ql-gunzipper::zlib-decompression-error :superclass ql-gunzipper::decompression-error)
(:mop-direct ql-gunzipper::zlib-decompression-error :prototype #<ql-gunzipper::zlib-decompression-error #x00033599D530>)
(:mop-direct ql-gunzipper::deflate-decompression-error :superclass ql-gunzipper::decompression-error)
(:mop-direct ql-gunzipper::deflate-decompression-error :package-name "QL-GUNZIPPER")
(:mop-direct ql-gunzipper::deflate-decompression-error :precedance
 (ql-gunzipper::decompression-error common-lisp:simple-error common-lisp:simple-condition common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ql-gunzipper::deflate-decompression-error :classof clos:standard-class)
(:mop-direct ql-gunzipper::deflate-decompression-error :typeof clos:standard-class)
(:mop-direct ql-gunzipper::deflate-decompression-error :superclass ql-gunzipper::decompression-error)
(:mop-direct ql-gunzipper::deflate-decompression-error :prototype #<ql-gunzipper::deflate-decompression-error #x0003359AE170>)
(:mop-direct ql-gunzipper::decompression-error :prototype #<ql-gunzipper::decompression-error #x0003359B9BB0>)
(:mop-direct asdf/action:operation-definition-error :superclass common-lisp:simple-error)
(:mop-direct asdf/action:operation-definition-error :package-name "ASDF/ACTION")
(:mop-direct asdf/action:operation-definition-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/action:operation-definition-error :classof clos:standard-class)
(:mop-direct asdf/action:operation-definition-error :typeof clos:standard-class)
(:mop-direct asdf/action:operation-definition-error :superclass common-lisp:simple-error)
(:mop-direct asdf/action:operation-definition-error :prototype #<asdf/action:operation-definition-error #x0003359C1278>)
(:mop-direct common-lisp:simple-error :prototype #<common-lisp:simple-error #x0003359C4080>)
(:mop-direct common-lisp:simple-condition :prototype #<common-lisp:simple-condition #x0003359C69B8>)
(:mop-direct common-lisp:warning :superclass common-lisp:condition)
(:mop-direct asdf/output-translations:invalid-output-translation :superclass common-lisp:warning)
(:mop-direct asdf/parse-defsystem:bad-system-name :superclass common-lisp:warning)
(:mop-direct asdf/operate:recursive-operate :superclass common-lisp:warning)
(:mop-direct uiop/lisp-build:compile-failed-warning :superclass common-lisp:warning)
(:mop-direct uiop/lisp-build:compile-warned-warning :superclass common-lisp:warning)
(:mop-direct uiop/version:deprecated-function-warning :superclass common-lisp:warning)
(:mop-direct asdf-2.26::invalid-output-translation :superclass common-lisp:warning)
(:mop-direct asdf-2.26::invalid-source-registry :superclass common-lisp:warning)
(:mop-direct common-lisp:simple-warning :superclass common-lisp:warning)
(:mop-direct clos:clos-warning :superclass common-lisp:warning)
(:mop-direct common-lisp:style-warning :superclass common-lisp:warning)
(:mop-direct asdf/source-registry:invalid-source-registry :superclass common-lisp:warning)
(:mop-direct common-lisp:warning :package-name "COMMON-LISP")
(:mop-direct common-lisp:warning :precedance (common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:warning :classof clos:standard-class)
(:mop-direct common-lisp:warning :typeof clos:standard-class)
(:mop-direct common-lisp:warning :superclass common-lisp:condition)
(:mop-direct asdf/output-translations:invalid-output-translation :superclass uiop/configuration:invalid-configuration)
(:mop-direct asdf/output-translations:invalid-output-translation :superclass common-lisp:warning)
(:mop-direct asdf/output-translations:invalid-output-translation :package-name "ASDF/OUTPUT-TRANSLATIONS")
(:mop-direct asdf/output-translations:invalid-output-translation :precedance
 (uiop/configuration:invalid-configuration common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/output-translations:invalid-output-translation :classof clos:standard-class)
(:mop-direct asdf/output-translations:invalid-output-translation :typeof clos:standard-class)
(:mop-direct asdf/output-translations:invalid-output-translation :superclass common-lisp:warning)
(:mop-direct asdf/output-translations:invalid-output-translation :slot
 ((:name common-lisp:format) (:ordinal 1)
  (:initform (uiop/common-lisp::compatfmt "~@<Invalid asdf output-translation ~S~@[ in ~S~]~@{ ~@?~}~@:>"))))
(:mop-direct asdf/output-translations:invalid-output-translation :prototype
 #<asdf/output-translations:invalid-output-translation #x000335960AE0>)
(:mop-direct asdf/parse-defsystem:bad-system-name :superclass common-lisp:warning)
(:mop-direct asdf/parse-defsystem:bad-system-name :package-name "ASDF/PARSE-DEFSYSTEM")
(:mop-direct asdf/parse-defsystem:bad-system-name :precedance
 (common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/parse-defsystem:bad-system-name :classof clos:standard-class)
(:mop-direct asdf/parse-defsystem:bad-system-name :typeof clos:standard-class)
(:mop-direct asdf/parse-defsystem:bad-system-name :superclass common-lisp:warning)
(:mop-direct asdf/parse-defsystem:bad-system-name :slot
 ((:name asdf/component:name) (:ordinal 1) (:initargs (:name)) (:readers (asdf/component:component-name))))
(:mop-direct asdf/parse-defsystem:bad-system-name :slot
 ((:name asdf/component:source-file) (:ordinal 2) (:initargs (:source-file)) (:readers (asdf/system:system-source-file))))
(:mop-direct asdf/parse-defsystem:bad-system-name :prototype #<asdf/parse-defsystem:bad-system-name #x0003359E8F38>)
(:mop-direct asdf/operate:recursive-operate :superclass common-lisp:warning)
(:mop-direct asdf/operate:recursive-operate :package-name "ASDF/OPERATE")
(:mop-direct asdf/operate:recursive-operate :precedance (common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/operate:recursive-operate :classof clos:standard-class)
(:mop-direct asdf/operate:recursive-operate :typeof clos:standard-class)
(:mop-direct asdf/operate:recursive-operate :superclass common-lisp:warning)
(:mop-direct asdf/operate:recursive-operate :slot
 ((:name asdf/operation:operation) (:ordinal 1) (:initargs (:operation)) (:readers (asdf/operate::condition-operation))))
(:mop-direct asdf/operate:recursive-operate :slot
 ((:name asdf/component:component) (:ordinal 2) (:initargs (:component)) (:readers (asdf/operate::condition-component))))
(:mop-direct asdf/operate:recursive-operate :slot
 ((:name asdf/action:action) (:ordinal 3) (:initargs (:action)) (:readers (asdf/operate::condition-action))))
(:mop-direct asdf/operate:recursive-operate :prototype #<asdf/operate:recursive-operate #x0003359FBBB8>)
(:mop-direct uiop/lisp-build:compile-failed-warning :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-failed-warning :superclass common-lisp:warning)
(:mop-direct uiop/lisp-build:compile-failed-warning :package-name "UIOP/LISP-BUILD")
(:mop-direct uiop/lisp-build:compile-failed-warning :precedance
 (uiop/lisp-build:compile-condition common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct uiop/lisp-build:compile-failed-warning :classof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-failed-warning :typeof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-failed-warning :superclass common-lisp:warning)
(:mop-direct uiop/lisp-build:compile-failed-warning :prototype #<uiop/lisp-build:compile-failed-warning #x000335960C80>)
(:mop-direct uiop/lisp-build:compile-warned-warning :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-warned-warning :superclass common-lisp:warning)
(:mop-direct uiop/lisp-build:compile-warned-warning :package-name "UIOP/LISP-BUILD")
(:mop-direct uiop/lisp-build:compile-warned-warning :precedance
 (uiop/lisp-build:compile-condition common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct uiop/lisp-build:compile-warned-warning :classof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-warned-warning :typeof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-warned-warning :superclass common-lisp:warning)
(:mop-direct uiop/lisp-build:compile-warned-warning :prototype #<uiop/lisp-build:compile-warned-warning #x000335960CE0>)
(:mop-direct uiop/version:deprecated-function-warning :superclass uiop/version:deprecated-function-condition)
(:mop-direct uiop/version:deprecated-function-warning :superclass common-lisp:warning)
(:mop-direct uiop/version:deprecated-function-warning :package-name "UIOP/VERSION")
(:mop-direct uiop/version:deprecated-function-warning :precedance
 (uiop/version:deprecated-function-condition common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct uiop/version:deprecated-function-warning :classof clos:standard-class)
(:mop-direct uiop/version:deprecated-function-warning :typeof clos:standard-class)
(:mop-direct uiop/version:deprecated-function-warning :superclass common-lisp:warning)

(:mop-direct asdf-2.26::invalid-output-translation :superclass asdf-2.26::invalid-configuration)
(:mop-direct asdf-2.26::invalid-output-translation :superclass common-lisp:warning)
(:mop-direct asdf-2.26::invalid-output-translation :package-name "ASDF-2.26")
(:mop-direct asdf-2.26::invalid-output-translation :precedance
 (asdf-2.26::invalid-configuration common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26::invalid-output-translation :classof clos:standard-class)
(:mop-direct asdf-2.26::invalid-output-translation :typeof clos:standard-class)
(:mop-direct asdf-2.26::invalid-output-translation :superclass common-lisp:warning)
(:mop-direct asdf-2.26::invalid-output-translation :slot
 ((:name common-lisp:format) (:ordinal 1) (:initform (asdf-2.26::compatfmt "~@<Invalid asdf output-translation ~S~@[ in ~S~]~@{ ~@?~}~@:>"))))
(:mop-direct asdf-2.26::invalid-output-translation :prototype #<asdf-2.26::invalid-output-translation #x000335961690>)
(:mop-direct asdf-2.26::invalid-source-registry :superclass asdf-2.26::invalid-configuration)
(:mop-direct asdf-2.26::invalid-source-registry :superclass common-lisp:warning)
(:mop-direct asdf-2.26::invalid-source-registry :package-name "ASDF-2.26")
(:mop-direct asdf-2.26::invalid-source-registry :precedance
 (asdf-2.26::invalid-configuration common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26::invalid-source-registry :classof clos:standard-class)
(:mop-direct asdf-2.26::invalid-source-registry :typeof clos:standard-class)
(:mop-direct asdf-2.26::invalid-source-registry :superclass common-lisp:warning)
(:mop-direct asdf-2.26::invalid-source-registry :slot
 ((:name common-lisp:format) (:ordinal 1) (:initform (asdf-2.26::compatfmt "~@<Invalid source registry ~S~@[ in ~S~]~@{ ~@?~}~@:>"))))
(:mop-direct asdf-2.26::invalid-source-registry :prototype #<asdf-2.26::invalid-source-registry #x0003359617C8>)
(:mop-direct common-lisp:simple-warning :superclass common-lisp:simple-condition)
(:mop-direct common-lisp:simple-warning :superclass common-lisp:warning)
(:mop-direct asdf/action:operation-definition-warning :superclass common-lisp:simple-warning)
(:mop-direct common-lisp:simple-warning :package-name "COMMON-LISP")
(:mop-direct common-lisp:simple-warning :precedance
 (common-lisp:simple-condition common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:simple-warning :classof clos:standard-class)
(:mop-direct common-lisp:simple-warning :typeof clos:standard-class)
(:mop-direct common-lisp:simple-warning :superclass common-lisp:warning)
(:mop-direct asdf/action:operation-definition-warning :superclass common-lisp:simple-warning)
(:mop-direct asdf/action:operation-definition-warning :package-name "ASDF/ACTION")
(:mop-direct asdf/action:operation-definition-warning :precedance
 (common-lisp:simple-warning common-lisp:simple-condition common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/action:operation-definition-warning :classof clos:standard-class)
(:mop-direct asdf/action:operation-definition-warning :typeof clos:standard-class)
(:mop-direct asdf/action:operation-definition-warning :superclass common-lisp:simple-warning)
(:mop-direct asdf/action:operation-definition-warning :prototype #<asdf/action:operation-definition-warning #x0003359630A0>)
(:mop-direct common-lisp:simple-warning :prototype #<common-lisp:simple-warning #x0003359630C8>)
(:mop-direct clos:clos-warning :superclass common-lisp:warning)
(:mop-direct clos::simple-clos-warning :superclass clos:clos-warning)
(:mop-direct clos:gf-replacing-method-warning :superclass clos:clos-warning)
(:mop-direct clos:gf-already-called-warning :superclass clos:clos-warning)
(:mop-direct clos:clos-warning :package-name "CLOS")
(:mop-direct clos:clos-warning :precedance (common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct clos:clos-warning :classof clos:standard-class)
(:mop-direct clos:clos-warning :typeof clos:standard-class)
(:mop-direct clos:clos-warning :superclass common-lisp:warning)
(:mop-direct clos::simple-clos-warning :superclass common-lisp:simple-condition)
(:mop-direct clos::simple-clos-warning :superclass clos:clos-warning)
(:mop-direct clos::simple-clos-warning :package-name "CLOS")
(:mop-direct clos::simple-clos-warning :precedance
 (common-lisp:simple-condition clos:clos-warning common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct clos::simple-clos-warning :classof clos:standard-class)
(:mop-direct clos::simple-clos-warning :typeof clos:standard-class)
(:mop-direct clos::simple-clos-warning :superclass clos:clos-warning)
(:mop-direct clos::simple-clos-warning :prototype #<clos::simple-clos-warning #x000335961A28>)
(:mop-direct clos:gf-replacing-method-warning :superclass clos:clos-warning)
(:mop-direct clos::simple-gf-replacing-method-warning :superclass clos:gf-replacing-method-warning)
(:mop-direct clos:gf-replacing-method-warning :package-name "CLOS")
(:mop-direct clos:gf-replacing-method-warning :precedance
 (clos:clos-warning common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct clos:gf-replacing-method-warning :classof clos:standard-class)
(:mop-direct clos:gf-replacing-method-warning :typeof clos:standard-class)
(:mop-direct clos:gf-replacing-method-warning :superclass clos:clos-warning)
(:mop-direct clos::simple-gf-replacing-method-warning :superclass common-lisp:simple-condition)
(:mop-direct clos::simple-gf-replacing-method-warning :superclass clos:gf-replacing-method-warning)
(:mop-direct clos::simple-gf-replacing-method-warning :package-name "CLOS")
(:mop-direct clos::simple-gf-replacing-method-warning :precedance
 (common-lisp:simple-condition clos:gf-replacing-method-warning clos:clos-warning common-lisp:warning common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos::simple-gf-replacing-method-warning :classof clos:standard-class)
(:mop-direct clos::simple-gf-replacing-method-warning :typeof clos:standard-class)
(:mop-direct clos::simple-gf-replacing-method-warning :superclass clos:gf-replacing-method-warning)
(:mop-direct clos::simple-gf-replacing-method-warning :prototype #<clos::simple-gf-replacing-method-warning #x0003359619D8>)
(:mop-direct clos:gf-replacing-method-warning :prototype #<clos:gf-replacing-method-warning #x000335A5D1B0>)
(:mop-direct clos:gf-already-called-warning :superclass clos:clos-warning)
(:mop-direct clos::simple-gf-already-called-warning :superclass clos:gf-already-called-warning)
(:mop-direct clos:gf-already-called-warning :package-name "CLOS")
(:mop-direct clos:gf-already-called-warning :precedance
 (clos:clos-warning common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct clos:gf-already-called-warning :classof clos:standard-class)
(:mop-direct clos:gf-already-called-warning :typeof clos:standard-class)
(:mop-direct clos:gf-already-called-warning :superclass clos:clos-warning)
(:mop-direct clos::simple-gf-already-called-warning :superclass common-lisp:simple-condition)
(:mop-direct clos::simple-gf-already-called-warning :superclass clos:gf-already-called-warning)
(:mop-direct clos::simple-gf-already-called-warning :package-name "CLOS")
(:mop-direct clos::simple-gf-already-called-warning :precedance
 (common-lisp:simple-condition clos:gf-already-called-warning clos:clos-warning common-lisp:warning common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos::simple-gf-already-called-warning :classof clos:standard-class)
(:mop-direct clos::simple-gf-already-called-warning :typeof clos:standard-class)
(:mop-direct clos::simple-gf-already-called-warning :superclass clos:gf-already-called-warning)
(:mop-direct clos::simple-gf-already-called-warning :prototype #<clos::simple-gf-already-called-warning #x000335961A00>)
(:mop-direct clos:gf-already-called-warning :prototype #<clos:gf-already-called-warning #x000335A6CF80>)
(:mop-direct clos:clos-warning :prototype #<clos:clos-warning #x000335A6FBD8>)
(:mop-direct common-lisp:style-warning :superclass common-lisp:warning)
(:mop-direct closer-mop::defmethod-without-generic-function :superclass common-lisp:style-warning)
(:mop-direct uiop/version:deprecated-function-style-warning :superclass common-lisp:style-warning)
(:mop-direct uiop/utility:simple-style-warning :superclass common-lisp:style-warning)
(:mop-direct system::simple-style-warning :superclass common-lisp:style-warning)
(:mop-direct common-lisp:style-warning :package-name "COMMON-LISP")
(:mop-direct common-lisp:style-warning :precedance (common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:style-warning :classof clos:standard-class)
(:mop-direct common-lisp:style-warning :typeof clos:standard-class)
(:mop-direct common-lisp:style-warning :superclass common-lisp:warning)
(:mop-direct closer-mop::defmethod-without-generic-function :superclass common-lisp:style-warning)
(:mop-direct closer-mop::defmethod-without-generic-function :package-name "CLOSER-MOP")
(:mop-direct closer-mop::defmethod-without-generic-function :precedance
 (common-lisp:style-warning common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct closer-mop::defmethod-without-generic-function :classof clos:standard-class)
(:mop-direct closer-mop::defmethod-without-generic-function :typeof clos:standard-class)
(:mop-direct closer-mop::defmethod-without-generic-function :superclass common-lisp:style-warning)
(:mop-direct closer-mop::defmethod-without-generic-function :slot
 ((:name closer-mop::name) (:ordinal 1) (:initargs (:name)) (:readers (closer-mop::dwg-name))))
(:mop-direct closer-mop::defmethod-without-generic-function :prototype #<closer-mop::defmethod-without-generic-function #x000335A7F0D8>)
(:mop-direct uiop/version:deprecated-function-style-warning :superclass uiop/version:deprecated-function-condition)
(:mop-direct uiop/version:deprecated-function-style-warning :superclass common-lisp:style-warning)
(:mop-direct uiop/version:deprecated-function-style-warning :package-name "UIOP/VERSION")
(:mop-direct uiop/version:deprecated-function-style-warning :precedance
 (uiop/version:deprecated-function-condition common-lisp:style-warning common-lisp:warning common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct uiop/version:deprecated-function-style-warning :classof clos:standard-class)
(:mop-direct uiop/version:deprecated-function-style-warning :typeof clos:standard-class)
(:mop-direct uiop/version:deprecated-function-style-warning :superclass common-lisp:style-warning)

(:mop-direct uiop/utility:simple-style-warning :superclass common-lisp:simple-condition)
(:mop-direct uiop/utility:simple-style-warning :superclass common-lisp:style-warning)
(:mop-direct uiop/utility:simple-style-warning :package-name "UIOP/UTILITY")
(:mop-direct uiop/utility:simple-style-warning :precedance
 (common-lisp:simple-condition common-lisp:style-warning common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct uiop/utility:simple-style-warning :classof clos:standard-class)
(:mop-direct uiop/utility:simple-style-warning :typeof clos:standard-class)
(:mop-direct uiop/utility:simple-style-warning :superclass common-lisp:style-warning)
(:mop-direct uiop/utility:simple-style-warning :prototype #<uiop/utility:simple-style-warning #x000335961838>)
(:mop-direct system::simple-style-warning :superclass common-lisp:simple-condition)
(:mop-direct system::simple-style-warning :superclass common-lisp:style-warning)
(:mop-direct system::simple-style-warning :package-name "SYSTEM")
(:mop-direct system::simple-style-warning :precedance
 (common-lisp:simple-condition common-lisp:style-warning common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-style-warning :classof clos:standard-class)
(:mop-direct system::simple-style-warning :typeof clos:standard-class)
(:mop-direct system::simple-style-warning :superclass common-lisp:style-warning)
(:mop-direct system::simple-style-warning :prototype #<system::simple-style-warning #x000335963078>)
(:mop-direct common-lisp:style-warning :prototype #<common-lisp:style-warning #x000335A9F788>)
(:mop-direct asdf/source-registry:invalid-source-registry :superclass uiop/configuration:invalid-configuration)
(:mop-direct asdf/source-registry:invalid-source-registry :superclass common-lisp:warning)
(:mop-direct asdf/source-registry:invalid-source-registry :package-name "ASDF/SOURCE-REGISTRY")
(:mop-direct asdf/source-registry:invalid-source-registry :precedance
 (uiop/configuration:invalid-configuration common-lisp:warning common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/source-registry:invalid-source-registry :classof clos:standard-class)
(:mop-direct asdf/source-registry:invalid-source-registry :typeof clos:standard-class)
(:mop-direct asdf/source-registry:invalid-source-registry :superclass common-lisp:warning)
(:mop-direct asdf/source-registry:invalid-source-registry :slot
 ((:name common-lisp:format) (:ordinal 1) (:initform (uiop/common-lisp::compatfmt "~@<Invalid source registry ~S~@[ in ~S~]~@{ ~@?~}~@:>"))))
(:mop-direct asdf/source-registry:invalid-source-registry :prototype #<asdf/source-registry:invalid-source-registry #x0003359609A8>)
(:mop-direct common-lisp:warning :prototype #<common-lisp:warning #x000335AAD358>)
(:mop-direct common-lisp:serious-condition :superclass common-lisp:condition)
(:mop-direct system::simple-serious-condition :superclass common-lisp:serious-condition)
(:mop-direct system::interrupt-condition :superclass common-lisp:serious-condition)
(:mop-direct common-lisp:storage-condition :superclass common-lisp:serious-condition)
(:mop-direct common-lisp:error :superclass common-lisp:serious-condition)
(:mop-direct common-lisp:serious-condition :package-name "COMMON-LISP")
(:mop-direct common-lisp:serious-condition :precedance (common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:serious-condition :classof clos:standard-class)
(:mop-direct common-lisp:serious-condition :typeof clos:standard-class)
(:mop-direct common-lisp:serious-condition :superclass common-lisp:condition)
(:mop-direct system::simple-serious-condition :superclass common-lisp:simple-condition)
(:mop-direct system::simple-serious-condition :superclass common-lisp:serious-condition)
(:mop-direct system::simple-serious-condition :package-name "SYSTEM")
(:mop-direct system::simple-serious-condition :precedance
 (common-lisp:simple-condition common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-serious-condition :classof clos:standard-class)
(:mop-direct system::simple-serious-condition :typeof clos:standard-class)
(:mop-direct system::simple-serious-condition :superclass common-lisp:serious-condition)
(:mop-direct system::simple-serious-condition :prototype #<system::simple-serious-condition #x0003359619B0>)
(:mop-direct system::interrupt-condition :superclass common-lisp:serious-condition)
(:mop-direct system::simple-interrupt-condition :superclass system::interrupt-condition)
(:mop-direct system::interrupt-condition :package-name "SYSTEM")
(:mop-direct system::interrupt-condition :precedance
 (common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::interrupt-condition :classof clos:standard-class)
(:mop-direct system::interrupt-condition :typeof clos:standard-class)
(:mop-direct system::interrupt-condition :superclass common-lisp:serious-condition)
(:mop-direct system::simple-interrupt-condition :superclass common-lisp:simple-condition)
(:mop-direct system::simple-interrupt-condition :superclass system::interrupt-condition)
(:mop-direct system::simple-interrupt-condition :package-name "SYSTEM")
(:mop-direct system::simple-interrupt-condition :precedance
 (common-lisp:simple-condition system::interrupt-condition common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct system::simple-interrupt-condition :classof clos:standard-class)
(:mop-direct system::simple-interrupt-condition :typeof clos:standard-class)
(:mop-direct system::simple-interrupt-condition :superclass system::interrupt-condition)
(:mop-direct system::simple-interrupt-condition :prototype #<system::simple-interrupt-condition #x000335961960>)
(:mop-direct system::interrupt-condition :prototype #<system::interrupt-condition #x000335ACAA68>)
(:mop-direct common-lisp:storage-condition :superclass common-lisp:serious-condition)
(:mop-direct system::simple-storage-condition :superclass common-lisp:storage-condition)
(:mop-direct common-lisp:storage-condition :package-name "COMMON-LISP")
(:mop-direct common-lisp:storage-condition :precedance
 (common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:storage-condition :classof clos:standard-class)
(:mop-direct common-lisp:storage-condition :typeof clos:standard-class)
(:mop-direct common-lisp:storage-condition :superclass common-lisp:serious-condition)
(:mop-direct system::simple-storage-condition :superclass common-lisp:simple-condition)
(:mop-direct system::simple-storage-condition :superclass common-lisp:storage-condition)
(:mop-direct system::simple-storage-condition :package-name "SYSTEM")
(:mop-direct system::simple-storage-condition :precedance
 (common-lisp:simple-condition common-lisp:storage-condition common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct system::simple-storage-condition :classof clos:standard-class)
(:mop-direct system::simple-storage-condition :typeof clos:standard-class)
(:mop-direct system::simple-storage-condition :superclass common-lisp:storage-condition)
(:mop-direct system::simple-storage-condition :prototype #<system::simple-storage-condition #x000335961988>)
(:mop-direct common-lisp:storage-condition :prototype #<common-lisp:storage-condition #x000335AD9B08>)
(:mop-direct common-lisp:error :superclass common-lisp:serious-condition)
(:mop-direct ext:os-error :superclass common-lisp:error)
(:mop-direct common-lisp:file-error :superclass common-lisp:error)
(:mop-direct common-lisp:stream-error :superclass common-lisp:error)
(:mop-direct common-lisp:parse-error :superclass common-lisp:error)
(:mop-direct common-lisp:print-not-readable :superclass common-lisp:error)
(:mop-direct common-lisp:package-error :superclass common-lisp:error)
(:mop-direct common-lisp:type-error :superclass common-lisp:error)
(:mop-direct common-lisp:cell-error :superclass common-lisp:error)
(:mop-direct common-lisp:arithmetic-error :superclass common-lisp:error)
(:mop-direct common-lisp:control-error :superclass common-lisp:error)
(:mop-direct common-lisp:program-error :superclass common-lisp:error)
(:mop-direct common-lisp:simple-error :superclass common-lisp:error)
(:mop-direct clos::missing-load-form :superclass common-lisp:error)
(:mop-direct asdf-2.26:system-definition-error :superclass common-lisp:error)
(:mop-direct asdf-2.26:operation-error :superclass common-lisp:error)
(:mop-direct ql-http::match-failure :superclass common-lisp:error)
(:mop-direct ql-http::end-of-data :superclass common-lisp:error)
(:mop-direct ql-http:fetch-error :superclass common-lisp:error)
(:mop-direct ql-dist:subscription-unavailable :superclass common-lisp:error)
(:mop-direct ql-dist:invalid-local-archive :superclass common-lisp:error)
(:mop-direct ql-dist:unknown-dist :superclass common-lisp:error)
(:mop-direct quicklisp-client:system-not-found :superclass common-lisp:error)
(:mop-direct quicklisp-client::system-not-quickloadable :superclass common-lisp:error)
(:mop-direct quicklisp-client::invalid-client-file :superclass common-lisp:error)
(:mop-direct quicklisp-client::invalid-client-info :superclass common-lisp:error)
(:mop-direct ql-bundle::bundle-error :superclass common-lisp:error)
(:mop-direct uiop/utility:not-implemented-error :superclass common-lisp:error)
(:mop-direct uiop/utility:parameter-error :superclass common-lisp:error)
(:mop-direct uiop/version:deprecated-function-error :superclass common-lisp:error)
(:mop-direct uiop/version:deprecated-function-should-be-deleted :superclass common-lisp:error)
(:mop-direct uiop/lisp-build:compile-file-error :superclass common-lisp:error)
(:mop-direct uiop/lisp-build:compile-warned-error :superclass common-lisp:error)
(:mop-direct uiop/lisp-build:compile-failed-error :superclass common-lisp:error)
(:mop-direct uiop/run-program:subprocess-error :superclass common-lisp:error)
(:mop-direct asdf/session:system-definition-error :superclass common-lisp:error)
(:mop-direct asdf/backward-interface:operation-error :superclass common-lisp:error)
(:mop-direct qlqs-http::match-failure :superclass common-lisp:error)
(:mop-direct qlqs-http::end-of-data :superclass common-lisp:error)
(:mop-direct common-lisp:error :package-name "COMMON-LISP")
(:mop-direct common-lisp:error :precedance (common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:error :classof clos:standard-class)
(:mop-direct common-lisp:error :typeof clos:standard-class)
(:mop-direct common-lisp:error :superclass common-lisp:serious-condition)
(:mop-direct ext:os-error :superclass common-lisp:error)
(:mop-direct system::simple-os-error :superclass ext:os-error)
(:mop-direct ext:os-error :package-name "EXT")
(:mop-direct ext:os-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ext:os-error :classof clos:standard-class)
(:mop-direct ext:os-error :typeof clos:standard-class)
(:mop-direct ext:os-error :superclass common-lisp:error)
(:mop-direct system::simple-os-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-os-error :superclass ext:os-error)
(:mop-direct system::simple-os-error :package-name "SYSTEM")
(:mop-direct system::simple-os-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition ext:os-error common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-os-error :classof clos:standard-class)
(:mop-direct system::simple-os-error :typeof clos:standard-class)
(:mop-direct system::simple-os-error :superclass ext:os-error)
(:mop-direct system::simple-os-error :prototype #<system::simple-os-error #x000335963598>)
(:mop-direct ext:os-error :prototype #<ext:os-error #x00033596FF40>)
(:mop-direct common-lisp:file-error :superclass common-lisp:error)
(:mop-direct system::simple-file-error :superclass common-lisp:file-error)
(:mop-direct common-lisp:file-error :package-name "COMMON-LISP")
(:mop-direct common-lisp:file-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:file-error :classof clos:standard-class)
(:mop-direct common-lisp:file-error :typeof clos:standard-class)
(:mop-direct common-lisp:file-error :superclass common-lisp:error)
(:mop-direct common-lisp:file-error :slot
 ((:name system::$pathname) (:ordinal 1) (:initargs (:pathname)) (:readers (common-lisp:file-error-pathname))))
(:mop-direct system::simple-file-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-file-error :superclass common-lisp:file-error)
(:mop-direct system::simple-file-error :package-name "SYSTEM")
(:mop-direct system::simple-file-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:file-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-file-error :classof clos:standard-class)
(:mop-direct system::simple-file-error :typeof clos:standard-class)
(:mop-direct system::simple-file-error :superclass common-lisp:file-error)
(:mop-direct system::simple-file-error :prototype #<system::simple-file-error #x000335963568>)
(:mop-direct common-lisp:file-error :prototype #<common-lisp:file-error #x000335983708>)
(:mop-direct common-lisp:stream-error :superclass common-lisp:error)
(:mop-direct system::simple-stream-error :superclass common-lisp:stream-error)
(:mop-direct common-lisp:reader-error :superclass common-lisp:stream-error)
(:mop-direct common-lisp:end-of-file :superclass common-lisp:stream-error)
(:mop-direct common-lisp:stream-error :package-name "COMMON-LISP")
(:mop-direct common-lisp:stream-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:stream-error :classof clos:standard-class)
(:mop-direct common-lisp:stream-error :typeof clos:standard-class)
(:mop-direct common-lisp:stream-error :superclass common-lisp:error)
(:mop-direct common-lisp:stream-error :slot
 ((:name system::$stream) (:ordinal 1) (:initargs (:stream)) (:readers (common-lisp:stream-error-stream))))
(:mop-direct system::simple-stream-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-stream-error :superclass common-lisp:stream-error)
(:mop-direct system::simple-stream-error :package-name "SYSTEM")
(:mop-direct system::simple-stream-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:stream-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-stream-error :classof clos:standard-class)
(:mop-direct system::simple-stream-error :typeof clos:standard-class)
(:mop-direct system::simple-stream-error :superclass common-lisp:stream-error)
(:mop-direct system::simple-stream-error :prototype #<system::simple-stream-error #x0003359634D8>)
(:mop-direct common-lisp:reader-error :superclass common-lisp:parse-error)
(:mop-direct common-lisp:reader-error :superclass common-lisp:stream-error)
(:mop-direct system::simple-reader-error :superclass common-lisp:reader-error)
(:mop-direct common-lisp:reader-error :package-name "COMMON-LISP")
(:mop-direct common-lisp:reader-error :precedance
 (common-lisp:parse-error common-lisp:stream-error common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:reader-error :classof clos:standard-class)
(:mop-direct common-lisp:reader-error :typeof clos:standard-class)
(:mop-direct common-lisp:reader-error :superclass common-lisp:stream-error)
(:mop-direct system::simple-reader-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-reader-error :superclass common-lisp:reader-error)
(:mop-direct system::simple-reader-error :package-name "SYSTEM")
(:mop-direct system::simple-reader-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:reader-error common-lisp:parse-error common-lisp:stream-error
  common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-reader-error :classof clos:standard-class)
(:mop-direct system::simple-reader-error :typeof clos:standard-class)
(:mop-direct system::simple-reader-error :superclass common-lisp:reader-error)
(:mop-direct system::simple-reader-error :prototype #<system::simple-reader-error #x000335963538>)
(:mop-direct common-lisp:reader-error :prototype #<common-lisp:reader-error #x0003359A3EA8>)
(:mop-direct common-lisp:end-of-file :superclass common-lisp:stream-error)
(:mop-direct system::simple-end-of-file :superclass common-lisp:end-of-file)
(:mop-direct common-lisp:end-of-file :package-name "COMMON-LISP")
(:mop-direct common-lisp:end-of-file :precedance
 (common-lisp:stream-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:end-of-file :classof clos:standard-class)
(:mop-direct common-lisp:end-of-file :typeof clos:standard-class)
(:mop-direct common-lisp:end-of-file :superclass common-lisp:stream-error)
(:mop-direct system::simple-end-of-file :superclass common-lisp:simple-error)
(:mop-direct system::simple-end-of-file :superclass common-lisp:end-of-file)
(:mop-direct system::simple-end-of-file :package-name "SYSTEM")
(:mop-direct system::simple-end-of-file :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:end-of-file common-lisp:stream-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-end-of-file :classof clos:standard-class)
(:mop-direct system::simple-end-of-file :typeof clos:standard-class)
(:mop-direct system::simple-end-of-file :superclass common-lisp:end-of-file)
(:mop-direct system::simple-end-of-file :prototype #<system::simple-end-of-file #x000335963508>)
(:mop-direct common-lisp:end-of-file :prototype #<common-lisp:end-of-file #x0003359B3958>)
(:mop-direct common-lisp:stream-error :prototype #<common-lisp:stream-error #x0003359B6288>)
(:mop-direct common-lisp:parse-error :superclass common-lisp:error)
(:mop-direct system::simple-parse-error :superclass common-lisp:parse-error)
(:mop-direct common-lisp:reader-error :superclass common-lisp:parse-error)
(:mop-direct common-lisp:parse-error :package-name "COMMON-LISP")
(:mop-direct common-lisp:parse-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:parse-error :classof clos:standard-class)
(:mop-direct common-lisp:parse-error :typeof clos:standard-class)
(:mop-direct common-lisp:parse-error :superclass common-lisp:error)
(:mop-direct system::simple-parse-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-parse-error :superclass common-lisp:parse-error)
(:mop-direct system::simple-parse-error :package-name "SYSTEM")
(:mop-direct system::simple-parse-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:parse-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-parse-error :classof clos:standard-class)
(:mop-direct system::simple-parse-error :typeof clos:standard-class)
(:mop-direct system::simple-parse-error :superclass common-lisp:parse-error)
(:mop-direct system::simple-parse-error :prototype #<system::simple-parse-error #x0003359634B0>)
(:mop-direct common-lisp:reader-error :superclass common-lisp:parse-error)
(:mop-direct common-lisp:reader-error :superclass common-lisp:stream-error)
(:mop-direct system::simple-reader-error :superclass common-lisp:reader-error)
(:mop-direct common-lisp:reader-error :package-name "COMMON-LISP")
(:mop-direct common-lisp:reader-error :precedance
 (common-lisp:parse-error common-lisp:stream-error common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:reader-error :classof clos:standard-class)
(:mop-direct common-lisp:reader-error :typeof clos:standard-class)
(:mop-direct common-lisp:reader-error :superclass common-lisp:parse-error)
(:mop-direct system::simple-reader-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-reader-error :superclass common-lisp:reader-error)
(:mop-direct system::simple-reader-error :package-name "SYSTEM")
(:mop-direct system::simple-reader-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:reader-error common-lisp:parse-error common-lisp:stream-error
  common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-reader-error :classof clos:standard-class)
(:mop-direct system::simple-reader-error :typeof clos:standard-class)
(:mop-direct system::simple-reader-error :superclass common-lisp:reader-error)
(:mop-direct system::simple-reader-error :prototype #<system::simple-reader-error #x000335963538>)
(:mop-direct common-lisp:reader-error :prototype #<common-lisp:reader-error #x0003359A3EA8>)
(:mop-direct common-lisp:parse-error :prototype #<common-lisp:parse-error #x0003359D6890>)
(:mop-direct common-lisp:print-not-readable :superclass common-lisp:error)
(:mop-direct system::simple-print-not-readable :superclass common-lisp:print-not-readable)
(:mop-direct common-lisp:print-not-readable :package-name "COMMON-LISP")
(:mop-direct common-lisp:print-not-readable :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:print-not-readable :classof clos:standard-class)
(:mop-direct common-lisp:print-not-readable :typeof clos:standard-class)
(:mop-direct common-lisp:print-not-readable :superclass common-lisp:error)
(:mop-direct common-lisp:print-not-readable :slot
 ((:name system::$object) (:ordinal 1) (:initargs (:object)) (:readers (common-lisp:print-not-readable-object))))
(:mop-direct system::simple-print-not-readable :superclass common-lisp:simple-error)
(:mop-direct system::simple-print-not-readable :superclass common-lisp:print-not-readable)
(:mop-direct system::simple-print-not-readable :package-name "SYSTEM")
(:mop-direct system::simple-print-not-readable :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:print-not-readable common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-print-not-readable :classof clos:standard-class)
(:mop-direct system::simple-print-not-readable :typeof clos:standard-class)
(:mop-direct system::simple-print-not-readable :superclass common-lisp:print-not-readable)
(:mop-direct system::simple-print-not-readable :prototype #<system::simple-print-not-readable #x000335963480>)
(:mop-direct common-lisp:print-not-readable :prototype #<common-lisp:print-not-readable #x0003359E8788>)
(:mop-direct common-lisp:package-error :superclass common-lisp:error)
(:mop-direct system::simple-package-error :superclass common-lisp:package-error)
(:mop-direct common-lisp:package-error :package-name "COMMON-LISP")
(:mop-direct common-lisp:package-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:package-error :classof clos:standard-class)
(:mop-direct common-lisp:package-error :typeof clos:standard-class)
(:mop-direct common-lisp:package-error :superclass common-lisp:error)
(:mop-direct common-lisp:package-error :slot
 ((:name system::$package) (:ordinal 1) (:initargs (:package)) (:readers (common-lisp:package-error-package))))
(:mop-direct system::simple-package-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-package-error :superclass common-lisp:package-error)
(:mop-direct system::simple-package-error :package-name "SYSTEM")
(:mop-direct system::simple-package-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:package-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-package-error :classof clos:standard-class)
(:mop-direct system::simple-package-error :typeof clos:standard-class)
(:mop-direct system::simple-package-error :superclass common-lisp:package-error)
(:mop-direct system::simple-package-error :prototype #<system::simple-package-error #x000335963450>)
(:mop-direct common-lisp:package-error :prototype #<common-lisp:package-error #x0003359FA318>)
(:mop-direct common-lisp:type-error :superclass common-lisp:error)
(:mop-direct common-lisp:simple-type-error :superclass common-lisp:type-error)
(:mop-direct system::argument-list-dotted :superclass common-lisp:type-error)
(:mop-direct system::charset-type-error :superclass common-lisp:type-error)
(:mop-direct system::keyword-error :superclass common-lisp:type-error)
(:mop-direct common-lisp:type-error :package-name "COMMON-LISP")
(:mop-direct common-lisp:type-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:type-error :classof clos:standard-class)
(:mop-direct common-lisp:type-error :typeof clos:standard-class)
(:mop-direct common-lisp:type-error :superclass common-lisp:error)
(:mop-direct common-lisp:type-error :slot ((:name system::$datum) (:ordinal 1) (:initargs (:datum)) (:readers (common-lisp:type-error-datum))))
(:mop-direct common-lisp:type-error :slot
 ((:name system::$expected-type) (:ordinal 2) (:initargs (:expected-type)) (:readers (common-lisp:type-error-expected-type))))
(:mop-direct common-lisp:simple-type-error :superclass common-lisp:simple-condition)
(:mop-direct common-lisp:simple-type-error :superclass common-lisp:type-error)
(:mop-direct clos:method-call-type-error :superclass common-lisp:simple-type-error)
(:mop-direct common-lisp:simple-type-error :package-name "COMMON-LISP")
(:mop-direct common-lisp:simple-type-error :precedance
 (common-lisp:simple-condition common-lisp:type-error common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:simple-type-error :classof clos:standard-class)
(:mop-direct common-lisp:simple-type-error :typeof clos:standard-class)
(:mop-direct common-lisp:simple-type-error :superclass common-lisp:type-error)
(:mop-direct clos:method-call-type-error :superclass common-lisp:simple-type-error)
(:mop-direct clos:method-call-type-error :superclass clos:method-call-error)
(:mop-direct clos:method-call-type-error :package-name "CLOS")
(:mop-direct clos:method-call-type-error :precedance
 (common-lisp:simple-type-error clos:method-call-error common-lisp:simple-error common-lisp:simple-condition common-lisp:type-error
  common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct clos:method-call-type-error :classof clos:standard-class)
(:mop-direct clos:method-call-type-error :typeof clos:standard-class)
(:mop-direct clos:method-call-type-error :superclass common-lisp:simple-type-error)
(:mop-direct clos:method-call-type-error :prototype #<clos:method-call-type-error #x0003359630F0>)
(:mop-direct common-lisp:simple-type-error :prototype #<common-lisp:simple-type-error #x000335963140>)
(:mop-direct system::argument-list-dotted :superclass common-lisp:program-error)
(:mop-direct system::argument-list-dotted :superclass common-lisp:type-error)
(:mop-direct system::simple-argument-list-dotted :superclass system::argument-list-dotted)
(:mop-direct system::argument-list-dotted :package-name "SYSTEM")
(:mop-direct system::argument-list-dotted :precedance
 (common-lisp:program-error common-lisp:type-error common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct system::argument-list-dotted :classof clos:standard-class)
(:mop-direct system::argument-list-dotted :typeof clos:standard-class)
(:mop-direct system::argument-list-dotted :superclass common-lisp:type-error)
(:mop-direct system::simple-argument-list-dotted :superclass common-lisp:simple-error)
(:mop-direct system::simple-argument-list-dotted :superclass system::argument-list-dotted)
(:mop-direct system::simple-argument-list-dotted :package-name "SYSTEM")
(:mop-direct system::simple-argument-list-dotted :precedance
 (common-lisp:simple-error common-lisp:simple-condition system::argument-list-dotted common-lisp:program-error common-lisp:type-error
  common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-argument-list-dotted :classof clos:standard-class)
(:mop-direct system::simple-argument-list-dotted :typeof clos:standard-class)
(:mop-direct system::simple-argument-list-dotted :superclass system::argument-list-dotted)
(:mop-direct system::simple-argument-list-dotted :prototype #<system::simple-argument-list-dotted #x000335963418>)
(:mop-direct system::argument-list-dotted :prototype #<system::argument-list-dotted #x000335A26648>)
(:mop-direct system::charset-type-error :superclass common-lisp:type-error)
(:mop-direct ext:simple-charset-type-error :superclass system::charset-type-error)
(:mop-direct system::charset-type-error :package-name "SYSTEM")
(:mop-direct system::charset-type-error :precedance
 (common-lisp:type-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::charset-type-error :classof clos:standard-class)
(:mop-direct system::charset-type-error :typeof clos:standard-class)
(:mop-direct system::charset-type-error :superclass common-lisp:type-error)
(:mop-direct ext:simple-charset-type-error :superclass common-lisp:simple-error)
(:mop-direct ext:simple-charset-type-error :superclass system::charset-type-error)
(:mop-direct ext:simple-charset-type-error :package-name "EXT")
(:mop-direct ext:simple-charset-type-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition system::charset-type-error common-lisp:type-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ext:simple-charset-type-error :classof clos:standard-class)
(:mop-direct ext:simple-charset-type-error :typeof clos:standard-class)
(:mop-direct ext:simple-charset-type-error :superclass system::charset-type-error)
(:mop-direct ext:simple-charset-type-error :prototype #<ext:simple-charset-type-error #x0003359633E0>)
(:mop-direct system::charset-type-error :prototype #<system::charset-type-error #x000335A365B8>)
(:mop-direct system::keyword-error :superclass common-lisp:program-error)
(:mop-direct system::keyword-error :superclass common-lisp:type-error)
(:mop-direct system::simple-keyword-error :superclass system::keyword-error)
(:mop-direct system::keyword-error :package-name "SYSTEM")
(:mop-direct system::keyword-error :precedance
 (common-lisp:program-error common-lisp:type-error common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct system::keyword-error :classof clos:standard-class)
(:mop-direct system::keyword-error :typeof clos:standard-class)
(:mop-direct system::keyword-error :superclass common-lisp:type-error)
(:mop-direct system::simple-keyword-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-keyword-error :superclass system::keyword-error)
(:mop-direct system::simple-keyword-error :package-name "SYSTEM")
(:mop-direct system::simple-keyword-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition system::keyword-error common-lisp:program-error common-lisp:type-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-keyword-error :classof clos:standard-class)
(:mop-direct system::simple-keyword-error :typeof clos:standard-class)
(:mop-direct system::simple-keyword-error :superclass system::keyword-error)
(:mop-direct system::simple-keyword-error :prototype #<system::simple-keyword-error #x0003359633A8>)
(:mop-direct system::keyword-error :prototype #<system::keyword-error #x000335A468A0>)
(:mop-direct common-lisp:type-error :prototype #<common-lisp:type-error #x000335A491D8>)
(:mop-direct common-lisp:cell-error :superclass common-lisp:error)
(:mop-direct system::simple-cell-error :superclass common-lisp:cell-error)
(:mop-direct common-lisp:unbound-slot :superclass common-lisp:cell-error)
(:mop-direct common-lisp:undefined-function :superclass common-lisp:cell-error)
(:mop-direct common-lisp:unbound-variable :superclass common-lisp:cell-error)
(:mop-direct common-lisp:cell-error :package-name "COMMON-LISP")
(:mop-direct common-lisp:cell-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:cell-error :classof clos:standard-class)
(:mop-direct common-lisp:cell-error :typeof clos:standard-class)
(:mop-direct common-lisp:cell-error :superclass common-lisp:error)
(:mop-direct common-lisp:cell-error :slot ((:name system::$name) (:ordinal 1) (:initargs (:name)) (:readers (common-lisp:cell-error-name))))
(:mop-direct system::simple-cell-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-cell-error :superclass common-lisp:cell-error)
(:mop-direct system::simple-cell-error :package-name "SYSTEM")
(:mop-direct system::simple-cell-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:cell-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-cell-error :classof clos:standard-class)
(:mop-direct system::simple-cell-error :typeof clos:standard-class)
(:mop-direct system::simple-cell-error :superclass common-lisp:cell-error)
(:mop-direct system::simple-cell-error :prototype #<system::simple-cell-error #x000335963210>)
(:mop-direct common-lisp:unbound-slot :superclass common-lisp:cell-error)
(:mop-direct system::simple-unbound-slot :superclass common-lisp:unbound-slot)
(:mop-direct common-lisp:unbound-slot :package-name "COMMON-LISP")
(:mop-direct common-lisp:unbound-slot :precedance
 (common-lisp:cell-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:unbound-slot :classof clos:standard-class)
(:mop-direct common-lisp:unbound-slot :typeof clos:standard-class)
(:mop-direct common-lisp:unbound-slot :superclass common-lisp:cell-error)
(:mop-direct common-lisp:unbound-slot :slot
 ((:name system::$instance) (:ordinal 1) (:initargs (:instance)) (:readers (common-lisp:unbound-slot-instance))))
(:mop-direct system::simple-unbound-slot :superclass common-lisp:simple-error)
(:mop-direct system::simple-unbound-slot :superclass common-lisp:unbound-slot)
(:mop-direct system::simple-unbound-slot :package-name "SYSTEM")
(:mop-direct system::simple-unbound-slot :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:unbound-slot common-lisp:cell-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-unbound-slot :classof clos:standard-class)
(:mop-direct system::simple-unbound-slot :typeof clos:standard-class)
(:mop-direct system::simple-unbound-slot :superclass common-lisp:unbound-slot)
(:mop-direct system::simple-unbound-slot :prototype #<system::simple-unbound-slot #x000335963178>)
(:mop-direct common-lisp:unbound-slot :prototype #<common-lisp:unbound-slot #x000335A6B450>)
(:mop-direct common-lisp:undefined-function :superclass common-lisp:cell-error)
(:mop-direct system::simple-undefined-function :superclass common-lisp:undefined-function)
(:mop-direct common-lisp:undefined-function :package-name "COMMON-LISP")
(:mop-direct common-lisp:undefined-function :precedance
 (common-lisp:cell-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:undefined-function :classof clos:standard-class)
(:mop-direct common-lisp:undefined-function :typeof clos:standard-class)
(:mop-direct common-lisp:undefined-function :superclass common-lisp:cell-error)
(:mop-direct system::simple-undefined-function :superclass common-lisp:simple-error)
(:mop-direct system::simple-undefined-function :superclass common-lisp:undefined-function)
(:mop-direct system::simple-undefined-function :package-name "SYSTEM")
(:mop-direct system::simple-undefined-function :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:undefined-function common-lisp:cell-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-undefined-function :classof clos:standard-class)
(:mop-direct system::simple-undefined-function :typeof clos:standard-class)
(:mop-direct system::simple-undefined-function :superclass common-lisp:undefined-function)
(:mop-direct system::simple-undefined-function :prototype #<system::simple-undefined-function #x0003359631B0>)
(:mop-direct common-lisp:undefined-function :prototype #<common-lisp:undefined-function #x000335A7B570>)
(:mop-direct common-lisp:unbound-variable :superclass common-lisp:cell-error)
(:mop-direct system::simple-unbound-variable :superclass common-lisp:unbound-variable)
(:mop-direct common-lisp:unbound-variable :package-name "COMMON-LISP")
(:mop-direct common-lisp:unbound-variable :precedance
 (common-lisp:cell-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:unbound-variable :classof clos:standard-class)
(:mop-direct common-lisp:unbound-variable :typeof clos:standard-class)
(:mop-direct common-lisp:unbound-variable :superclass common-lisp:cell-error)
(:mop-direct system::simple-unbound-variable :superclass common-lisp:simple-error)
(:mop-direct system::simple-unbound-variable :superclass common-lisp:unbound-variable)
(:mop-direct system::simple-unbound-variable :package-name "SYSTEM")
(:mop-direct system::simple-unbound-variable :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:unbound-variable common-lisp:cell-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-unbound-variable :classof clos:standard-class)
(:mop-direct system::simple-unbound-variable :typeof clos:standard-class)
(:mop-direct system::simple-unbound-variable :superclass common-lisp:unbound-variable)
(:mop-direct system::simple-unbound-variable :prototype #<system::simple-unbound-variable #x0003359631E0>)
(:mop-direct common-lisp:unbound-variable :prototype #<common-lisp:unbound-variable #x000335A8B810>)
(:mop-direct common-lisp:cell-error :prototype #<common-lisp:cell-error #x000335A8E140>)
(:mop-direct common-lisp:arithmetic-error :superclass common-lisp:error)
(:mop-direct system::simple-arithmetic-error :superclass common-lisp:arithmetic-error)
(:mop-direct common-lisp:floating-point-invalid-operation :superclass common-lisp:arithmetic-error)
(:mop-direct common-lisp:floating-point-inexact :superclass common-lisp:arithmetic-error)
(:mop-direct common-lisp:floating-point-underflow :superclass common-lisp:arithmetic-error)
(:mop-direct common-lisp:floating-point-overflow :superclass common-lisp:arithmetic-error)
(:mop-direct common-lisp:division-by-zero :superclass common-lisp:arithmetic-error)
(:mop-direct common-lisp:arithmetic-error :package-name "COMMON-LISP")
(:mop-direct common-lisp:arithmetic-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:arithmetic-error :classof clos:standard-class)
(:mop-direct common-lisp:arithmetic-error :typeof clos:standard-class)
(:mop-direct common-lisp:arithmetic-error :superclass common-lisp:error)
(:mop-direct common-lisp:arithmetic-error :slot
 ((:name system::$operation) (:ordinal 1) (:initargs (:operation)) (:readers (common-lisp:arithmetic-error-operation))))
(:mop-direct common-lisp:arithmetic-error :slot
 ((:name system::$operands) (:ordinal 2) (:initargs (:operands)) (:readers (common-lisp:arithmetic-error-operands))))
(:mop-direct system::simple-arithmetic-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-arithmetic-error :superclass common-lisp:arithmetic-error)
(:mop-direct system::simple-arithmetic-error :package-name "SYSTEM")
(:mop-direct system::simple-arithmetic-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:arithmetic-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-arithmetic-error :classof clos:standard-class)
(:mop-direct system::simple-arithmetic-error :typeof clos:standard-class)
(:mop-direct system::simple-arithmetic-error :superclass common-lisp:arithmetic-error)
(:mop-direct system::simple-arithmetic-error :prototype #<system::simple-arithmetic-error #x0003359632E8>)
(:mop-direct common-lisp:floating-point-invalid-operation :superclass common-lisp:arithmetic-error)
(:mop-direct common-lisp:floating-point-invalid-operation :package-name "COMMON-LISP")
(:mop-direct common-lisp:floating-point-invalid-operation :precedance
 (common-lisp:arithmetic-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:floating-point-invalid-operation :classof clos:standard-class)
(:mop-direct common-lisp:floating-point-invalid-operation :typeof clos:standard-class)
(:mop-direct common-lisp:floating-point-invalid-operation :superclass common-lisp:arithmetic-error)
(:mop-direct common-lisp:floating-point-invalid-operation :prototype #<common-lisp:floating-point-invalid-operation #x000335AA9C38>)
(:mop-direct common-lisp:floating-point-inexact :superclass common-lisp:arithmetic-error)
(:mop-direct common-lisp:floating-point-inexact :package-name "COMMON-LISP")
(:mop-direct common-lisp:floating-point-inexact :precedance
 (common-lisp:arithmetic-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:floating-point-inexact :classof clos:standard-class)
(:mop-direct common-lisp:floating-point-inexact :typeof clos:standard-class)
(:mop-direct common-lisp:floating-point-inexact :superclass common-lisp:arithmetic-error)
(:mop-direct common-lisp:floating-point-inexact :prototype #<common-lisp:floating-point-inexact #x000335AB15C0>)
(:mop-direct common-lisp:floating-point-underflow :superclass common-lisp:arithmetic-error)
(:mop-direct system::simple-floating-point-underflow :superclass common-lisp:floating-point-underflow)
(:mop-direct common-lisp:floating-point-underflow :package-name "COMMON-LISP")
(:mop-direct common-lisp:floating-point-underflow :precedance
 (common-lisp:arithmetic-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:floating-point-underflow :classof clos:standard-class)
(:mop-direct common-lisp:floating-point-underflow :typeof clos:standard-class)
(:mop-direct common-lisp:floating-point-underflow :superclass common-lisp:arithmetic-error)
(:mop-direct system::simple-floating-point-underflow :superclass common-lisp:simple-error)
(:mop-direct system::simple-floating-point-underflow :superclass common-lisp:floating-point-underflow)
(:mop-direct system::simple-floating-point-underflow :package-name "SYSTEM")
(:mop-direct system::simple-floating-point-underflow :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:floating-point-underflow common-lisp:arithmetic-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-floating-point-underflow :classof clos:standard-class)
(:mop-direct system::simple-floating-point-underflow :typeof clos:standard-class)
(:mop-direct system::simple-floating-point-underflow :superclass common-lisp:floating-point-underflow)
(:mop-direct system::simple-floating-point-underflow :prototype #<system::simple-floating-point-underflow #x000335963240>)
(:mop-direct common-lisp:floating-point-underflow :prototype #<common-lisp:floating-point-underflow #x000335AC25B8>)
(:mop-direct common-lisp:floating-point-overflow :superclass common-lisp:arithmetic-error)
(:mop-direct system::simple-floating-point-overflow :superclass common-lisp:floating-point-overflow)
(:mop-direct common-lisp:floating-point-overflow :package-name "COMMON-LISP")
(:mop-direct common-lisp:floating-point-overflow :precedance
 (common-lisp:arithmetic-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:floating-point-overflow :classof clos:standard-class)
(:mop-direct common-lisp:floating-point-overflow :typeof clos:standard-class)
(:mop-direct common-lisp:floating-point-overflow :superclass common-lisp:arithmetic-error)
(:mop-direct system::simple-floating-point-overflow :superclass common-lisp:simple-error)
(:mop-direct system::simple-floating-point-overflow :superclass common-lisp:floating-point-overflow)
(:mop-direct system::simple-floating-point-overflow :package-name "SYSTEM")
(:mop-direct system::simple-floating-point-overflow :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:floating-point-overflow common-lisp:arithmetic-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-floating-point-overflow :classof clos:standard-class)
(:mop-direct system::simple-floating-point-overflow :typeof clos:standard-class)
(:mop-direct system::simple-floating-point-overflow :superclass common-lisp:floating-point-overflow)
(:mop-direct system::simple-floating-point-overflow :prototype #<system::simple-floating-point-overflow #x000335963278>)
(:mop-direct common-lisp:floating-point-overflow :prototype #<common-lisp:floating-point-overflow #x000335AD2C20>)
(:mop-direct common-lisp:division-by-zero :superclass common-lisp:arithmetic-error)
(:mop-direct system::simple-division-by-zero :superclass common-lisp:division-by-zero)
(:mop-direct common-lisp:division-by-zero :package-name "COMMON-LISP")
(:mop-direct common-lisp:division-by-zero :precedance
 (common-lisp:arithmetic-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:division-by-zero :classof clos:standard-class)
(:mop-direct common-lisp:division-by-zero :typeof clos:standard-class)
(:mop-direct common-lisp:division-by-zero :superclass common-lisp:arithmetic-error)
(:mop-direct system::simple-division-by-zero :superclass common-lisp:simple-error)
(:mop-direct system::simple-division-by-zero :superclass common-lisp:division-by-zero)
(:mop-direct system::simple-division-by-zero :package-name "SYSTEM")
(:mop-direct system::simple-division-by-zero :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:division-by-zero common-lisp:arithmetic-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-division-by-zero :classof clos:standard-class)
(:mop-direct system::simple-division-by-zero :typeof clos:standard-class)
(:mop-direct system::simple-division-by-zero :superclass common-lisp:division-by-zero)
(:mop-direct system::simple-division-by-zero :prototype #<system::simple-division-by-zero #x0003359632B0>)
(:mop-direct common-lisp:division-by-zero :prototype #<common-lisp:division-by-zero #x000335AE30C8>)
(:mop-direct common-lisp:arithmetic-error :prototype #<common-lisp:arithmetic-error #x000335AE5A00>)
(:mop-direct common-lisp:control-error :superclass common-lisp:error)
(:mop-direct system::simple-control-error :superclass common-lisp:control-error)
(:mop-direct common-lisp:control-error :package-name "COMMON-LISP")
(:mop-direct common-lisp:control-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:control-error :classof clos:standard-class)
(:mop-direct common-lisp:control-error :typeof clos:standard-class)
(:mop-direct common-lisp:control-error :superclass common-lisp:error)
(:mop-direct system::simple-control-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-control-error :superclass common-lisp:control-error)
(:mop-direct system::simple-control-error :package-name "SYSTEM")
(:mop-direct system::simple-control-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:control-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-control-error :classof clos:standard-class)
(:mop-direct system::simple-control-error :typeof clos:standard-class)
(:mop-direct system::simple-control-error :superclass common-lisp:control-error)
(:mop-direct system::simple-control-error :prototype #<system::simple-control-error #x000335963320>)
(:mop-direct common-lisp:control-error :prototype #<common-lisp:control-error #x000335AF5188>)
(:mop-direct common-lisp:program-error :superclass common-lisp:error)
(:mop-direct system::simple-program-error :superclass common-lisp:program-error)
(:mop-direct system::argument-list-dotted :superclass common-lisp:program-error)
(:mop-direct system::keyword-error :superclass common-lisp:program-error)
(:mop-direct ext:source-program-error :superclass common-lisp:program-error)
(:mop-direct common-lisp:program-error :package-name "COMMON-LISP")
(:mop-direct common-lisp:program-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:program-error :classof clos:standard-class)
(:mop-direct common-lisp:program-error :typeof clos:standard-class)
(:mop-direct common-lisp:program-error :superclass common-lisp:error)
(:mop-direct system::simple-program-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-program-error :superclass common-lisp:program-error)
(:mop-direct system::simple-program-error :package-name "SYSTEM")
(:mop-direct system::simple-program-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:program-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-program-error :classof clos:standard-class)
(:mop-direct system::simple-program-error :typeof clos:standard-class)
(:mop-direct system::simple-program-error :superclass common-lisp:program-error)
(:mop-direct system::simple-program-error :prototype #<system::simple-program-error #x000335963380>)
(:mop-direct system::argument-list-dotted :superclass common-lisp:program-error)
(:mop-direct system::argument-list-dotted :superclass common-lisp:type-error)
(:mop-direct system::simple-argument-list-dotted :superclass system::argument-list-dotted)
(:mop-direct system::argument-list-dotted :package-name "SYSTEM")
(:mop-direct system::argument-list-dotted :precedance
 (common-lisp:program-error common-lisp:type-error common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct system::argument-list-dotted :classof clos:standard-class)
(:mop-direct system::argument-list-dotted :typeof clos:standard-class)
(:mop-direct system::argument-list-dotted :superclass common-lisp:program-error)
(:mop-direct system::simple-argument-list-dotted :superclass common-lisp:simple-error)
(:mop-direct system::simple-argument-list-dotted :superclass system::argument-list-dotted)
(:mop-direct system::simple-argument-list-dotted :package-name "SYSTEM")
(:mop-direct system::simple-argument-list-dotted :precedance
 (common-lisp:simple-error common-lisp:simple-condition system::argument-list-dotted common-lisp:program-error common-lisp:type-error
  common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-argument-list-dotted :classof clos:standard-class)
(:mop-direct system::simple-argument-list-dotted :typeof clos:standard-class)
(:mop-direct system::simple-argument-list-dotted :superclass system::argument-list-dotted)
(:mop-direct system::simple-argument-list-dotted :prototype #<system::simple-argument-list-dotted #x000335961DF0>)
(:mop-direct system::argument-list-dotted :prototype #<system::argument-list-dotted #x000335964E08>)
(:mop-direct system::keyword-error :superclass common-lisp:program-error)
(:mop-direct system::keyword-error :superclass common-lisp:type-error)
(:mop-direct system::simple-keyword-error :superclass system::keyword-error)
(:mop-direct system::keyword-error :package-name "SYSTEM")
(:mop-direct system::keyword-error :precedance
 (common-lisp:program-error common-lisp:type-error common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct system::keyword-error :classof clos:standard-class)
(:mop-direct system::keyword-error :typeof clos:standard-class)
(:mop-direct system::keyword-error :superclass common-lisp:program-error)
(:mop-direct system::simple-keyword-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-keyword-error :superclass system::keyword-error)
(:mop-direct system::simple-keyword-error :package-name "SYSTEM")
(:mop-direct system::simple-keyword-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition system::keyword-error common-lisp:program-error common-lisp:type-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-keyword-error :classof clos:standard-class)
(:mop-direct system::simple-keyword-error :typeof clos:standard-class)
(:mop-direct system::simple-keyword-error :superclass system::keyword-error)
(:mop-direct system::simple-keyword-error :prototype #<system::simple-keyword-error #x000335961D80>)
(:mop-direct system::keyword-error :prototype #<system::keyword-error #x000335964E58>)
(:mop-direct ext:source-program-error :superclass common-lisp:program-error)
(:mop-direct system::simple-source-program-error :superclass ext:source-program-error)
(:mop-direct ext:source-program-error :package-name "EXT")
(:mop-direct ext:source-program-error :precedance
 (common-lisp:program-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ext:source-program-error :classof clos:standard-class)
(:mop-direct ext:source-program-error :typeof clos:standard-class)
(:mop-direct ext:source-program-error :superclass common-lisp:program-error)
(:mop-direct ext:source-program-error :slot ((:name system::$form) (:ordinal 1) (:initargs (:form)) (:readers (ext:source-program-error-form))))
(:mop-direct ext:source-program-error :slot
 ((:name system::$detail) (:ordinal 2) (:initargs (:detail)) (:readers (ext:source-program-error-detail))))
(:mop-direct system::simple-source-program-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-source-program-error :superclass ext:source-program-error)
(:mop-direct system::simple-source-program-error :package-name "SYSTEM")
(:mop-direct system::simple-source-program-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition ext:source-program-error common-lisp:program-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-source-program-error :classof clos:standard-class)
(:mop-direct system::simple-source-program-error :typeof clos:standard-class)
(:mop-direct system::simple-source-program-error :superclass ext:source-program-error)
(:mop-direct system::simple-source-program-error :prototype #<system::simple-source-program-error #x000335961D20>)
(:mop-direct ext:source-program-error :prototype #<ext:source-program-error #x000335998720>)
(:mop-direct common-lisp:program-error :prototype #<common-lisp:program-error #x00033599B058>)
(:mop-direct common-lisp:simple-error :superclass common-lisp:simple-condition)
(:mop-direct common-lisp:simple-error :superclass common-lisp:error)
(:mop-direct system::simple-unbound-slot :superclass common-lisp:simple-error)
(:mop-direct system::simple-undefined-function :superclass common-lisp:simple-error)
(:mop-direct system::simple-unbound-variable :superclass common-lisp:simple-error)
(:mop-direct system::simple-cell-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-floating-point-underflow :superclass common-lisp:simple-error)
(:mop-direct system::simple-floating-point-overflow :superclass common-lisp:simple-error)
(:mop-direct system::simple-division-by-zero :superclass common-lisp:simple-error)
(:mop-direct system::simple-arithmetic-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-control-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-source-program-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-program-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-keyword-error :superclass common-lisp:simple-error)
(:mop-direct ext:simple-charset-type-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-argument-list-dotted :superclass common-lisp:simple-error)
(:mop-direct system::simple-package-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-print-not-readable :superclass common-lisp:simple-error)
(:mop-direct system::simple-parse-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-stream-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-end-of-file :superclass common-lisp:simple-error)
(:mop-direct system::simple-reader-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-file-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-os-error :superclass common-lisp:simple-error)
(:mop-direct clos:method-call-error :superclass common-lisp:simple-error)
(:mop-direct clos::simple-missing-load-form :superclass common-lisp:simple-error)
(:mop-direct ql-gunzipper::decompression-error :superclass common-lisp:simple-error)
(:mop-direct asdf/action:operation-definition-error :superclass common-lisp:simple-error)
(:mop-direct common-lisp:simple-error :package-name "COMMON-LISP")
(:mop-direct common-lisp:simple-error :precedance
 (common-lisp:simple-condition common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct common-lisp:simple-error :classof clos:standard-class)
(:mop-direct common-lisp:simple-error :typeof clos:standard-class)
(:mop-direct common-lisp:simple-error :superclass common-lisp:error)
(:mop-direct system::simple-unbound-slot :superclass common-lisp:simple-error)
(:mop-direct system::simple-unbound-slot :superclass common-lisp:unbound-slot)
(:mop-direct system::simple-unbound-slot :package-name "SYSTEM")
(:mop-direct system::simple-unbound-slot :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:unbound-slot common-lisp:cell-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-unbound-slot :classof clos:standard-class)
(:mop-direct system::simple-unbound-slot :typeof clos:standard-class)
(:mop-direct system::simple-unbound-slot :superclass common-lisp:simple-error)
(:mop-direct system::simple-unbound-slot :prototype #<system::simple-unbound-slot #x000335961B50>)
(:mop-direct system::simple-undefined-function :superclass common-lisp:simple-error)
(:mop-direct system::simple-undefined-function :superclass common-lisp:undefined-function)
(:mop-direct system::simple-undefined-function :package-name "SYSTEM")
(:mop-direct system::simple-undefined-function :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:undefined-function common-lisp:cell-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-undefined-function :classof clos:standard-class)
(:mop-direct system::simple-undefined-function :typeof clos:standard-class)
(:mop-direct system::simple-undefined-function :superclass common-lisp:simple-error)
(:mop-direct system::simple-undefined-function :prototype #<system::simple-undefined-function #x000335961B88>)
(:mop-direct system::simple-unbound-variable :superclass common-lisp:simple-error)
(:mop-direct system::simple-unbound-variable :superclass common-lisp:unbound-variable)
(:mop-direct system::simple-unbound-variable :package-name "SYSTEM")
(:mop-direct system::simple-unbound-variable :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:unbound-variable common-lisp:cell-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-unbound-variable :classof clos:standard-class)
(:mop-direct system::simple-unbound-variable :typeof clos:standard-class)
(:mop-direct system::simple-unbound-variable :superclass common-lisp:simple-error)
(:mop-direct system::simple-unbound-variable :prototype #<system::simple-unbound-variable #x000335961BB8>)
(:mop-direct system::simple-cell-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-cell-error :superclass common-lisp:cell-error)
(:mop-direct system::simple-cell-error :package-name "SYSTEM")
(:mop-direct system::simple-cell-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:cell-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-cell-error :classof clos:standard-class)
(:mop-direct system::simple-cell-error :typeof clos:standard-class)
(:mop-direct system::simple-cell-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-cell-error :prototype #<system::simple-cell-error #x000335961BE8>)
(:mop-direct system::simple-floating-point-underflow :superclass common-lisp:simple-error)
(:mop-direct system::simple-floating-point-underflow :superclass common-lisp:floating-point-underflow)
(:mop-direct system::simple-floating-point-underflow :package-name "SYSTEM")
(:mop-direct system::simple-floating-point-underflow :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:floating-point-underflow common-lisp:arithmetic-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-floating-point-underflow :classof clos:standard-class)
(:mop-direct system::simple-floating-point-underflow :typeof clos:standard-class)
(:mop-direct system::simple-floating-point-underflow :superclass common-lisp:simple-error)
(:mop-direct system::simple-floating-point-underflow :prototype #<system::simple-floating-point-underflow #x000335961C18>)
(:mop-direct system::simple-floating-point-overflow :superclass common-lisp:simple-error)
(:mop-direct system::simple-floating-point-overflow :superclass common-lisp:floating-point-overflow)
(:mop-direct system::simple-floating-point-overflow :package-name "SYSTEM")
(:mop-direct system::simple-floating-point-overflow :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:floating-point-overflow common-lisp:arithmetic-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-floating-point-overflow :classof clos:standard-class)
(:mop-direct system::simple-floating-point-overflow :typeof clos:standard-class)
(:mop-direct system::simple-floating-point-overflow :superclass common-lisp:simple-error)
(:mop-direct system::simple-floating-point-overflow :prototype #<system::simple-floating-point-overflow #x000335961C50>)
(:mop-direct system::simple-division-by-zero :superclass common-lisp:simple-error)
(:mop-direct system::simple-division-by-zero :superclass common-lisp:division-by-zero)
(:mop-direct system::simple-division-by-zero :package-name "SYSTEM")
(:mop-direct system::simple-division-by-zero :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:division-by-zero common-lisp:arithmetic-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-division-by-zero :classof clos:standard-class)
(:mop-direct system::simple-division-by-zero :typeof clos:standard-class)
(:mop-direct system::simple-division-by-zero :superclass common-lisp:simple-error)
(:mop-direct system::simple-division-by-zero :prototype #<system::simple-division-by-zero #x000335961C88>)
(:mop-direct system::simple-arithmetic-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-arithmetic-error :superclass common-lisp:arithmetic-error)
(:mop-direct system::simple-arithmetic-error :package-name "SYSTEM")
(:mop-direct system::simple-arithmetic-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:arithmetic-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-arithmetic-error :classof clos:standard-class)
(:mop-direct system::simple-arithmetic-error :typeof clos:standard-class)
(:mop-direct system::simple-arithmetic-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-arithmetic-error :prototype #<system::simple-arithmetic-error #x000335961CC0>)
(:mop-direct system::simple-control-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-control-error :superclass common-lisp:control-error)
(:mop-direct system::simple-control-error :package-name "SYSTEM")
(:mop-direct system::simple-control-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:control-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-control-error :classof clos:standard-class)
(:mop-direct system::simple-control-error :typeof clos:standard-class)
(:mop-direct system::simple-control-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-control-error :prototype #<system::simple-control-error #x000335961CF8>)
(:mop-direct system::simple-source-program-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-source-program-error :superclass ext:source-program-error)
(:mop-direct system::simple-source-program-error :package-name "SYSTEM")
(:mop-direct system::simple-source-program-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition ext:source-program-error common-lisp:program-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-source-program-error :classof clos:standard-class)
(:mop-direct system::simple-source-program-error :typeof clos:standard-class)
(:mop-direct system::simple-source-program-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-source-program-error :prototype #<system::simple-source-program-error #x000335961D20>)
(:mop-direct system::simple-program-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-program-error :superclass common-lisp:program-error)
(:mop-direct system::simple-program-error :package-name "SYSTEM")
(:mop-direct system::simple-program-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:program-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-program-error :classof clos:standard-class)
(:mop-direct system::simple-program-error :typeof clos:standard-class)
(:mop-direct system::simple-program-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-program-error :prototype #<system::simple-program-error #x000335961D58>)
(:mop-direct system::simple-keyword-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-keyword-error :superclass system::keyword-error)
(:mop-direct system::simple-keyword-error :package-name "SYSTEM")
(:mop-direct system::simple-keyword-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition system::keyword-error common-lisp:program-error common-lisp:type-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-keyword-error :classof clos:standard-class)
(:mop-direct system::simple-keyword-error :typeof clos:standard-class)
(:mop-direct system::simple-keyword-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-keyword-error :prototype #<system::simple-keyword-error #x000335961D80>)
(:mop-direct ext:simple-charset-type-error :superclass common-lisp:simple-error)
(:mop-direct ext:simple-charset-type-error :superclass system::charset-type-error)
(:mop-direct ext:simple-charset-type-error :package-name "EXT")
(:mop-direct ext:simple-charset-type-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition system::charset-type-error common-lisp:type-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ext:simple-charset-type-error :classof clos:standard-class)
(:mop-direct ext:simple-charset-type-error :typeof clos:standard-class)
(:mop-direct ext:simple-charset-type-error :superclass common-lisp:simple-error)
(:mop-direct ext:simple-charset-type-error :prototype #<ext:simple-charset-type-error #x000335961DB8>)
(:mop-direct system::simple-argument-list-dotted :superclass common-lisp:simple-error)
(:mop-direct system::simple-argument-list-dotted :superclass system::argument-list-dotted)
(:mop-direct system::simple-argument-list-dotted :package-name "SYSTEM")
(:mop-direct system::simple-argument-list-dotted :precedance
 (common-lisp:simple-error common-lisp:simple-condition system::argument-list-dotted common-lisp:program-error common-lisp:type-error
  common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-argument-list-dotted :classof clos:standard-class)
(:mop-direct system::simple-argument-list-dotted :typeof clos:standard-class)
(:mop-direct system::simple-argument-list-dotted :superclass common-lisp:simple-error)
(:mop-direct system::simple-argument-list-dotted :prototype #<system::simple-argument-list-dotted #x000335961DF0>)
(:mop-direct system::simple-package-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-package-error :superclass common-lisp:package-error)
(:mop-direct system::simple-package-error :package-name "SYSTEM")
(:mop-direct system::simple-package-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:package-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-package-error :classof clos:standard-class)
(:mop-direct system::simple-package-error :typeof clos:standard-class)
(:mop-direct system::simple-package-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-package-error :prototype #<system::simple-package-error #x000335961E28>)
(:mop-direct system::simple-print-not-readable :superclass common-lisp:simple-error)
(:mop-direct system::simple-print-not-readable :superclass common-lisp:print-not-readable)
(:mop-direct system::simple-print-not-readable :package-name "SYSTEM")
(:mop-direct system::simple-print-not-readable :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:print-not-readable common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-print-not-readable :classof clos:standard-class)
(:mop-direct system::simple-print-not-readable :typeof clos:standard-class)
(:mop-direct system::simple-print-not-readable :superclass common-lisp:simple-error)
(:mop-direct system::simple-print-not-readable :prototype #<system::simple-print-not-readable #x000335961E58>)
(:mop-direct system::simple-parse-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-parse-error :superclass common-lisp:parse-error)
(:mop-direct system::simple-parse-error :package-name "SYSTEM")
(:mop-direct system::simple-parse-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:parse-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-parse-error :classof clos:standard-class)
(:mop-direct system::simple-parse-error :typeof clos:standard-class)
(:mop-direct system::simple-parse-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-parse-error :prototype #<system::simple-parse-error #x000335961E88>)
(:mop-direct system::simple-stream-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-stream-error :superclass common-lisp:stream-error)
(:mop-direct system::simple-stream-error :package-name "SYSTEM")
(:mop-direct system::simple-stream-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:stream-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-stream-error :classof clos:standard-class)
(:mop-direct system::simple-stream-error :typeof clos:standard-class)
(:mop-direct system::simple-stream-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-stream-error :prototype #<system::simple-stream-error #x000335961EB0>)
(:mop-direct system::simple-end-of-file :superclass common-lisp:simple-error)
(:mop-direct system::simple-end-of-file :superclass common-lisp:end-of-file)
(:mop-direct system::simple-end-of-file :package-name "SYSTEM")
(:mop-direct system::simple-end-of-file :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:end-of-file common-lisp:stream-error common-lisp:error
  common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-end-of-file :classof clos:standard-class)
(:mop-direct system::simple-end-of-file :typeof clos:standard-class)
(:mop-direct system::simple-end-of-file :superclass common-lisp:simple-error)
(:mop-direct system::simple-end-of-file :prototype #<system::simple-end-of-file #x000335961EE0>)
(:mop-direct system::simple-reader-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-reader-error :superclass common-lisp:reader-error)
(:mop-direct system::simple-reader-error :package-name "SYSTEM")
(:mop-direct system::simple-reader-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:reader-error common-lisp:parse-error common-lisp:stream-error
  common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-reader-error :classof clos:standard-class)
(:mop-direct system::simple-reader-error :typeof clos:standard-class)
(:mop-direct system::simple-reader-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-reader-error :prototype #<system::simple-reader-error #x000335961F10>)
(:mop-direct system::simple-file-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-file-error :superclass common-lisp:file-error)
(:mop-direct system::simple-file-error :package-name "SYSTEM")
(:mop-direct system::simple-file-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:file-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-file-error :classof clos:standard-class)
(:mop-direct system::simple-file-error :typeof clos:standard-class)
(:mop-direct system::simple-file-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-file-error :prototype #<system::simple-file-error #x000335961F40>)
(:mop-direct system::simple-os-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-os-error :superclass ext:os-error)
(:mop-direct system::simple-os-error :package-name "SYSTEM")
(:mop-direct system::simple-os-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition ext:os-error common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct system::simple-os-error :classof clos:standard-class)
(:mop-direct system::simple-os-error :typeof clos:standard-class)
(:mop-direct system::simple-os-error :superclass common-lisp:simple-error)
(:mop-direct system::simple-os-error :prototype #<system::simple-os-error #x000335961F70>)
(:mop-direct clos:method-call-error :superclass common-lisp:simple-error)
(:mop-direct clos:method-call-type-error :superclass clos:method-call-error)
(:mop-direct clos:method-call-error :package-name "CLOS")
(:mop-direct clos:method-call-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos:method-call-error :classof clos:standard-class)
(:mop-direct clos:method-call-error :typeof clos:standard-class)
(:mop-direct clos:method-call-error :superclass common-lisp:simple-error)
(:mop-direct clos:method-call-error :slot
 ((:name system::$gf) (:ordinal 1) (:initargs (:generic-function)) (:readers (clos:method-call-error-generic-function))))
(:mop-direct clos:method-call-error :slot
 ((:name system::$method) (:ordinal 2) (:initargs (:method)) (:readers (clos:method-call-error-method))))
(:mop-direct clos:method-call-error :slot
 ((:name system::$args) (:ordinal 3) (:initargs (:argument-list)) (:readers (clos:method-call-error-argument-list))))
(:mop-direct clos:method-call-type-error :superclass common-lisp:simple-type-error)
(:mop-direct clos:method-call-type-error :superclass clos:method-call-error)
(:mop-direct clos:method-call-type-error :package-name "CLOS")
(:mop-direct clos:method-call-type-error :precedance
 (common-lisp:simple-type-error clos:method-call-error common-lisp:simple-error common-lisp:simple-condition common-lisp:type-error
  common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct clos:method-call-type-error :classof clos:standard-class)
(:mop-direct clos:method-call-type-error :typeof clos:standard-class)
(:mop-direct clos:method-call-type-error :superclass clos:method-call-error)
(:mop-direct clos:method-call-type-error :prototype #<clos:method-call-type-error #x000335961AC8>)
(:mop-direct clos:method-call-error :prototype #<clos:method-call-error #x000335961F98>)
(:mop-direct clos::simple-missing-load-form :superclass common-lisp:simple-error)
(:mop-direct clos::simple-missing-load-form :superclass clos::missing-load-form)
(:mop-direct clos::simple-missing-load-form :package-name "CLOS")
(:mop-direct clos::simple-missing-load-form :precedance
 (common-lisp:simple-error common-lisp:simple-condition clos::missing-load-form common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct clos::simple-missing-load-form :classof clos:standard-class)
(:mop-direct clos::simple-missing-load-form :typeof clos:standard-class)
(:mop-direct clos::simple-missing-load-form :superclass common-lisp:simple-error)
(:mop-direct clos::simple-missing-load-form :prototype #<clos::simple-missing-load-form #x000335961FD8>)
(:mop-direct ql-gunzipper::decompression-error :superclass common-lisp:simple-error)
(:mop-direct ql-gunzipper::gzip-decompression-error :superclass ql-gunzipper::decompression-error)
(:mop-direct ql-gunzipper::zlib-decompression-error :superclass ql-gunzipper::decompression-error)
(:mop-direct ql-gunzipper::deflate-decompression-error :superclass ql-gunzipper::decompression-error)
(:mop-direct ql-gunzipper::decompression-error :package-name "QL-GUNZIPPER")
(:mop-direct ql-gunzipper::decompression-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct ql-gunzipper::decompression-error :classof clos:standard-class)
(:mop-direct ql-gunzipper::decompression-error :typeof clos:standard-class)
(:mop-direct ql-gunzipper::decompression-error :superclass common-lisp:simple-error)
(:mop-direct ql-gunzipper::gzip-decompression-error :superclass ql-gunzipper::decompression-error)
(:mop-direct ql-gunzipper::gzip-decompression-error :package-name "QL-GUNZIPPER")
(:mop-direct ql-gunzipper::gzip-decompression-error :precedance
 (ql-gunzipper::decompression-error common-lisp:simple-error common-lisp:simple-condition common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ql-gunzipper::gzip-decompression-error :classof clos:standard-class)
(:mop-direct ql-gunzipper::gzip-decompression-error :typeof clos:standard-class)
(:mop-direct ql-gunzipper::gzip-decompression-error :superclass ql-gunzipper::decompression-error)
(:mop-direct ql-gunzipper::gzip-decompression-error :prototype #<ql-gunzipper::gzip-decompression-error #x000335962008>)
(:mop-direct ql-gunzipper::zlib-decompression-error :superclass ql-gunzipper::decompression-error)
(:mop-direct ql-gunzipper::zlib-decompression-error :package-name "QL-GUNZIPPER")
(:mop-direct ql-gunzipper::zlib-decompression-error :precedance
 (ql-gunzipper::decompression-error common-lisp:simple-error common-lisp:simple-condition common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ql-gunzipper::zlib-decompression-error :classof clos:standard-class)
(:mop-direct ql-gunzipper::zlib-decompression-error :typeof clos:standard-class)
(:mop-direct ql-gunzipper::zlib-decompression-error :superclass ql-gunzipper::decompression-error)
(:mop-direct ql-gunzipper::zlib-decompression-error :prototype #<ql-gunzipper::zlib-decompression-error #x000335962440>)
(:mop-direct ql-gunzipper::deflate-decompression-error :superclass ql-gunzipper::decompression-error)
(:mop-direct ql-gunzipper::deflate-decompression-error :package-name "QL-GUNZIPPER")
(:mop-direct ql-gunzipper::deflate-decompression-error :precedance
 (ql-gunzipper::decompression-error common-lisp:simple-error common-lisp:simple-condition common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ql-gunzipper::deflate-decompression-error :classof clos:standard-class)
(:mop-direct ql-gunzipper::deflate-decompression-error :typeof clos:standard-class)
(:mop-direct ql-gunzipper::deflate-decompression-error :superclass ql-gunzipper::decompression-error)
(:mop-direct ql-gunzipper::deflate-decompression-error :prototype #<ql-gunzipper::deflate-decompression-error #x0003359625C0>)
(:mop-direct ql-gunzipper::decompression-error :prototype #<ql-gunzipper::decompression-error #x000335962740>)
(:mop-direct asdf/action:operation-definition-error :superclass common-lisp:simple-error)
(:mop-direct asdf/action:operation-definition-error :package-name "ASDF/ACTION")
(:mop-direct asdf/action:operation-definition-error :precedance
 (common-lisp:simple-error common-lisp:simple-condition common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/action:operation-definition-error :classof clos:standard-class)
(:mop-direct asdf/action:operation-definition-error :typeof clos:standard-class)
(:mop-direct asdf/action:operation-definition-error :superclass common-lisp:simple-error)
(:mop-direct asdf/action:operation-definition-error :prototype #<asdf/action:operation-definition-error #x000335962768>)
(:mop-direct common-lisp:simple-error :prototype #<common-lisp:simple-error #x000335962790>)
(:mop-direct clos::missing-load-form :superclass common-lisp:error)
(:mop-direct clos::simple-missing-load-form :superclass clos::missing-load-form)
(:mop-direct clos::missing-load-form :package-name "CLOS")
(:mop-direct clos::missing-load-form :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct clos::missing-load-form :classof clos:standard-class)
(:mop-direct clos::missing-load-form :typeof clos:standard-class)
(:mop-direct clos::missing-load-form :superclass common-lisp:error)
(:mop-direct clos::missing-load-form :slot
 ((:name clos::$object) (:ordinal 1) (:initargs (:object)) (:readers (clos::missing-load-form-object))))
(:mop-direct clos::simple-missing-load-form :superclass common-lisp:simple-error)
(:mop-direct clos::simple-missing-load-form :superclass clos::missing-load-form)
(:mop-direct clos::simple-missing-load-form :package-name "CLOS")
(:mop-direct clos::simple-missing-load-form :precedance
 (common-lisp:simple-error common-lisp:simple-condition clos::missing-load-form common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct clos::simple-missing-load-form :classof clos:standard-class)
(:mop-direct clos::simple-missing-load-form :typeof clos:standard-class)
(:mop-direct clos::simple-missing-load-form :superclass clos::missing-load-form)
(:mop-direct clos::simple-missing-load-form :prototype #<clos::simple-missing-load-form #x000335961FD8>)
(:mop-direct clos::missing-load-form :prototype #<clos::missing-load-form #x000335AB9F50>)
(:mop-direct asdf-2.26:system-definition-error :superclass common-lisp:error)
(:mop-direct asdf-2.26:missing-component :superclass asdf-2.26:system-definition-error)
(:mop-direct asdf-2.26:duplicate-names :superclass asdf-2.26:system-definition-error)
(:mop-direct asdf-2.26:circular-dependency :superclass asdf-2.26:system-definition-error)
(:mop-direct asdf-2.26:load-system-definition-error :superclass asdf-2.26:system-definition-error)
(:mop-direct asdf-2.26::formatted-system-definition-error :superclass asdf-2.26:system-definition-error)
(:mop-direct asdf-2.26:system-definition-error :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:system-definition-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:system-definition-error :classof clos:standard-class)
(:mop-direct asdf-2.26:system-definition-error :typeof clos:standard-class)
(:mop-direct asdf-2.26:system-definition-error :superclass common-lisp:error)
(:mop-direct asdf-2.26:missing-component :superclass asdf-2.26:system-definition-error)
(:mop-direct asdf-2.26:missing-dependency :superclass asdf-2.26:missing-component)
(:mop-direct asdf-2.26:missing-component-of-version :superclass asdf-2.26:missing-component)
(:mop-direct asdf-2.26:missing-component :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:missing-component :precedance
 (asdf-2.26:system-definition-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf-2.26:missing-component :classof clos:standard-class)
(:mop-direct asdf-2.26:missing-component :typeof clos:standard-class)
(:mop-direct asdf-2.26:missing-component :superclass asdf-2.26:system-definition-error)
(:mop-direct asdf-2.26:missing-component :slot
 ((:name asdf-2.26::requires) (:ordinal 1) (:initform "(unnamed)") (:initargs (:requires)) (:readers (asdf-2.26::missing-requires))))
(:mop-direct asdf-2.26:missing-component :slot
 ((:name asdf-2.26::parent) (:ordinal 2) (:initargs (:parent)) (:readers (asdf-2.26::missing-parent))))
(:mop-direct asdf-2.26:missing-dependency :superclass asdf-2.26:missing-component)
(:mop-direct asdf-2.26:missing-dependency-of-version :superclass asdf-2.26:missing-dependency)
(:mop-direct asdf-2.26:missing-dependency :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:missing-dependency :precedance
 (asdf-2.26:missing-component asdf-2.26:system-definition-error common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:missing-dependency :classof clos:standard-class)
(:mop-direct asdf-2.26:missing-dependency :typeof clos:standard-class)
(:mop-direct asdf-2.26:missing-dependency :superclass asdf-2.26:missing-component)
(:mop-direct asdf-2.26:missing-dependency :slot
 ((:name asdf-2.26::required-by) (:ordinal 1) (:initargs (:required-by)) (:readers (asdf-2.26::missing-required-by))))
(:mop-direct asdf-2.26:missing-dependency-of-version :superclass asdf-2.26:missing-dependency)
(:mop-direct asdf-2.26:missing-dependency-of-version :superclass asdf-2.26:missing-component-of-version)
(:mop-direct asdf-2.26:missing-dependency-of-version :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:missing-dependency-of-version :precedance
 (asdf-2.26:missing-dependency asdf-2.26:missing-component-of-version asdf-2.26:missing-component asdf-2.26:system-definition-error
  common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:missing-dependency-of-version :classof clos:standard-class)
(:mop-direct asdf-2.26:missing-dependency-of-version :typeof clos:standard-class)
(:mop-direct asdf-2.26:missing-dependency-of-version :superclass asdf-2.26:missing-dependency)


(:mop-direct asdf-2.26:missing-component-of-version :superclass asdf-2.26:missing-component)
(:mop-direct asdf-2.26:missing-dependency-of-version :superclass asdf-2.26:missing-component-of-version)
(:mop-direct asdf-2.26:missing-component-of-version :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:missing-component-of-version :precedance
 (asdf-2.26:missing-component asdf-2.26:system-definition-error common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:missing-component-of-version :classof clos:standard-class)
(:mop-direct asdf-2.26:missing-component-of-version :typeof clos:standard-class)
(:mop-direct asdf-2.26:missing-component-of-version :superclass asdf-2.26:missing-component)
(:mop-direct asdf-2.26:missing-component-of-version :slot
 ((:name asdf-2.26:version) (:ordinal 1) (:initargs (:version)) (:readers (asdf-2.26::missing-version))))
(:mop-direct asdf-2.26:missing-dependency-of-version :superclass asdf-2.26:missing-dependency)
(:mop-direct asdf-2.26:missing-dependency-of-version :superclass asdf-2.26:missing-component-of-version)
(:mop-direct asdf-2.26:missing-dependency-of-version :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:missing-dependency-of-version :precedance
 (asdf-2.26:missing-dependency asdf-2.26:missing-component-of-version asdf-2.26:missing-component asdf-2.26:system-definition-error
  common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:missing-dependency-of-version :classof clos:standard-class)
(:mop-direct asdf-2.26:missing-dependency-of-version :typeof clos:standard-class)
(:mop-direct asdf-2.26:missing-dependency-of-version :superclass asdf-2.26:missing-component-of-version)



(:mop-direct asdf-2.26:duplicate-names :superclass asdf-2.26:system-definition-error)
(:mop-direct asdf-2.26:duplicate-names :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:duplicate-names :precedance
 (asdf-2.26:system-definition-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf-2.26:duplicate-names :classof clos:standard-class)
(:mop-direct asdf-2.26:duplicate-names :typeof clos:standard-class)
(:mop-direct asdf-2.26:duplicate-names :superclass asdf-2.26:system-definition-error)
(:mop-direct asdf-2.26:duplicate-names :slot
 ((:name asdf-2.26::name) (:ordinal 1) (:initargs (:name)) (:readers (asdf-2.26::duplicate-names-name))))
(:mop-direct asdf-2.26:duplicate-names :prototype #<asdf-2.26:duplicate-names #x00033596F058>)
(:mop-direct asdf-2.26:circular-dependency :superclass asdf-2.26:system-definition-error)
(:mop-direct asdf-2.26:circular-dependency :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:circular-dependency :precedance
 (asdf-2.26:system-definition-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf-2.26:circular-dependency :classof clos:standard-class)
(:mop-direct asdf-2.26:circular-dependency :typeof clos:standard-class)
(:mop-direct asdf-2.26:circular-dependency :superclass asdf-2.26:system-definition-error)
(:mop-direct asdf-2.26:circular-dependency :slot
 ((:name asdf-2.26::components) (:ordinal 1) (:initargs (:components)) (:readers (asdf-2.26::circular-dependency-components))))
(:mop-direct asdf-2.26:circular-dependency :prototype #<asdf-2.26:circular-dependency #x00033597D690>)
(:mop-direct asdf-2.26:load-system-definition-error :superclass asdf-2.26:system-definition-error)
(:mop-direct asdf-2.26:load-system-definition-error :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:load-system-definition-error :precedance
 (asdf-2.26:system-definition-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf-2.26:load-system-definition-error :classof clos:standard-class)
(:mop-direct asdf-2.26:load-system-definition-error :typeof clos:standard-class)
(:mop-direct asdf-2.26:load-system-definition-error :superclass asdf-2.26:system-definition-error)
(:mop-direct asdf-2.26:load-system-definition-error :slot
 ((:name asdf-2.26::name) (:ordinal 1) (:initargs (:name)) (:readers (asdf-2.26:error-name))))
(:mop-direct asdf-2.26:load-system-definition-error :slot
 ((:name common-lisp:pathname) (:ordinal 2) (:initargs (:pathname)) (:readers (asdf-2.26:error-pathname))))
(:mop-direct asdf-2.26:load-system-definition-error :slot
 ((:name common-lisp:condition) (:ordinal 3) (:initargs (:condition)) (:readers (asdf-2.26::error-condition))))
(:mop-direct asdf-2.26:load-system-definition-error :prototype #<asdf-2.26:load-system-definition-error #x00033598FD30>)
(:mop-direct asdf-2.26::formatted-system-definition-error :superclass asdf-2.26:system-definition-error)
(:mop-direct asdf-2.26::formatted-system-definition-error :package-name "ASDF-2.26")
(:mop-direct asdf-2.26::formatted-system-definition-error :precedance
 (asdf-2.26:system-definition-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf-2.26::formatted-system-definition-error :classof clos:standard-class)
(:mop-direct asdf-2.26::formatted-system-definition-error :typeof clos:standard-class)
(:mop-direct asdf-2.26::formatted-system-definition-error :superclass asdf-2.26:system-definition-error)
(:mop-direct asdf-2.26::formatted-system-definition-error :slot
 ((:name asdf-2.26::format-control) (:ordinal 1) (:initargs (:format-control)) (:readers (asdf-2.26::format-control))))
(:mop-direct asdf-2.26::formatted-system-definition-error :slot
 ((:name asdf-2.26::format-arguments) (:ordinal 2) (:initargs (:format-arguments)) (:readers (asdf-2.26::format-arguments))))
(:mop-direct asdf-2.26::formatted-system-definition-error :prototype #<asdf-2.26::formatted-system-definition-error #x0003359A1170>)
(:mop-direct asdf-2.26:system-definition-error :prototype #<asdf-2.26:system-definition-error #x0003359A9170>)
(:mop-direct asdf-2.26:operation-error :superclass common-lisp:error)
(:mop-direct asdf-2.26:compile-error :superclass asdf-2.26:operation-error)
(:mop-direct asdf-2.26:operation-error :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:operation-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:operation-error :classof clos:standard-class)
(:mop-direct asdf-2.26:operation-error :typeof clos:standard-class)
(:mop-direct asdf-2.26:operation-error :superclass common-lisp:error)
(:mop-direct asdf-2.26:operation-error :slot
 ((:name asdf-2.26:component) (:ordinal 1) (:initargs (:component)) (:readers (asdf-2.26:error-component))))
(:mop-direct asdf-2.26:operation-error :slot
 ((:name asdf-2.26:operation) (:ordinal 2) (:initargs (:operation)) (:readers (asdf-2.26:error-operation))))
(:mop-direct asdf-2.26:compile-error :superclass asdf-2.26:operation-error)
(:mop-direct asdf-2.26:compile-warned :superclass asdf-2.26:compile-error)
(:mop-direct asdf-2.26:compile-failed :superclass asdf-2.26:compile-error)
(:mop-direct asdf-2.26:compile-error :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:compile-error :precedance
 (asdf-2.26:operation-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:compile-error :classof clos:standard-class)
(:mop-direct asdf-2.26:compile-error :typeof clos:standard-class)
(:mop-direct asdf-2.26:compile-error :superclass asdf-2.26:operation-error)
(:mop-direct asdf-2.26:compile-warned :superclass asdf-2.26:compile-error)
(:mop-direct asdf-2.26:compile-warned :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:compile-warned :precedance
 (asdf-2.26:compile-error asdf-2.26:operation-error common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:compile-warned :classof clos:standard-class)
(:mop-direct asdf-2.26:compile-warned :typeof clos:standard-class)
(:mop-direct asdf-2.26:compile-warned :superclass asdf-2.26:compile-error)
(:mop-direct asdf-2.26:compile-warned :prototype #<asdf-2.26:compile-warned #x0003359BF558>)
(:mop-direct asdf-2.26:compile-failed :superclass asdf-2.26:compile-error)
(:mop-direct asdf-2.26:compile-failed :package-name "ASDF-2.26")
(:mop-direct asdf-2.26:compile-failed :precedance
 (asdf-2.26:compile-error asdf-2.26:operation-error common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf-2.26:compile-failed :classof clos:standard-class)
(:mop-direct asdf-2.26:compile-failed :typeof clos:standard-class)
(:mop-direct asdf-2.26:compile-failed :superclass asdf-2.26:compile-error)
(:mop-direct asdf-2.26:compile-failed :prototype #<asdf-2.26:compile-failed #x0003359CB798>)
(:mop-direct asdf-2.26:compile-error :prototype #<asdf-2.26:compile-error #x0003359CE0D0>)
(:mop-direct asdf-2.26:operation-error :prototype #<asdf-2.26:operation-error #x0003359D0A08>)
(:mop-direct ql-http::match-failure :superclass common-lisp:error)
(:mop-direct ql-http::match-failure :package-name "QL-HTTP")
(:mop-direct ql-http::match-failure :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ql-http::match-failure :classof clos:standard-class)
(:mop-direct ql-http::match-failure :typeof clos:standard-class)
(:mop-direct ql-http::match-failure :superclass common-lisp:error)
(:mop-direct ql-http::match-failure :prototype #<ql-http::match-failure #x0003359D7AB8>)
(:mop-direct ql-http::end-of-data :superclass common-lisp:error)
(:mop-direct ql-http::end-of-data :package-name "QL-HTTP")
(:mop-direct ql-http::end-of-data :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ql-http::end-of-data :classof clos:standard-class)
(:mop-direct ql-http::end-of-data :typeof clos:standard-class)
(:mop-direct ql-http::end-of-data :superclass common-lisp:error)
(:mop-direct ql-http::end-of-data :prototype #<ql-http::end-of-data #x0003359DEB58>)
(:mop-direct ql-http:fetch-error :superclass common-lisp:error)
(:mop-direct ql-http:too-many-redirects :superclass ql-http:fetch-error)
(:mop-direct ql-http:unexpected-http-status :superclass ql-http:fetch-error)
(:mop-direct ql-http:fetch-error :package-name "QL-HTTP")
(:mop-direct ql-http:fetch-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ql-http:fetch-error :classof clos:standard-class)
(:mop-direct ql-http:fetch-error :typeof clos:standard-class)
(:mop-direct ql-http:fetch-error :superclass common-lisp:error)
(:mop-direct ql-http:too-many-redirects :superclass ql-http:fetch-error)
(:mop-direct ql-http:too-many-redirects :package-name "QL-HTTP")
(:mop-direct ql-http:too-many-redirects :precedance
 (ql-http:fetch-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ql-http:too-many-redirects :classof clos:standard-class)
(:mop-direct ql-http:too-many-redirects :typeof clos:standard-class)
(:mop-direct ql-http:too-many-redirects :superclass ql-http:fetch-error)
(:mop-direct ql-http:too-many-redirects :slot ((:name ql-http:url) (:ordinal 1) (:initargs (:url)) (:readers (ql-http:too-many-redirects-url))))
(:mop-direct ql-http:too-many-redirects :slot
 ((:name ql-http::redirect-count) (:ordinal 2) (:initargs (:redirect-count)) (:readers (ql-http:too-many-redirects-count))))
(:mop-direct ql-http:too-many-redirects :prototype #<ql-http:too-many-redirects #x0003359EF990>)
(:mop-direct ql-http:unexpected-http-status :superclass ql-http:fetch-error)
(:mop-direct ql-http:unexpected-http-status :package-name "QL-HTTP")
(:mop-direct ql-http:unexpected-http-status :precedance
 (ql-http:fetch-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ql-http:unexpected-http-status :classof clos:standard-class)
(:mop-direct ql-http:unexpected-http-status :typeof clos:standard-class)
(:mop-direct ql-http:unexpected-http-status :superclass ql-http:fetch-error)
(:mop-direct ql-http:unexpected-http-status :slot
 ((:name ql-http::status-code) (:ordinal 1) (:initargs (:status-code)) (:readers (ql-http:unexpected-http-status-code))))
(:mop-direct ql-http:unexpected-http-status :slot
 ((:name ql-http:url) (:ordinal 2) (:initargs (:url)) (:readers (ql-http:unexpected-http-status-url))))
(:mop-direct ql-http:unexpected-http-status :prototype #<ql-http:unexpected-http-status #x000335A001B0>)
(:mop-direct ql-http:fetch-error :prototype #<ql-http:fetch-error #x000335A08010>)
(:mop-direct ql-dist:subscription-unavailable :superclass common-lisp:error)
(:mop-direct ql-dist:subscription-unavailable :package-name "QL-DIST")
(:mop-direct ql-dist:subscription-unavailable :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ql-dist:subscription-unavailable :classof clos:standard-class)
(:mop-direct ql-dist:subscription-unavailable :typeof clos:standard-class)
(:mop-direct ql-dist:subscription-unavailable :superclass common-lisp:error)
(:mop-direct ql-dist:subscription-unavailable :slot
 ((:name ql-dist::object) (:ordinal 1) (:initargs (:object)) (:readers (ql-dist::subscription-unavailable-object))))
(:mop-direct ql-dist:subscription-unavailable :prototype #<ql-dist:subscription-unavailable #x000335A116A8>)
(:mop-direct ql-dist:invalid-local-archive :superclass common-lisp:error)
(:mop-direct ql-dist:badly-sized-local-archive :superclass ql-dist:invalid-local-archive)
(:mop-direct ql-dist:missing-local-archive :superclass ql-dist:invalid-local-archive)
(:mop-direct ql-dist:invalid-local-archive :package-name "QL-DIST")
(:mop-direct ql-dist:invalid-local-archive :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ql-dist:invalid-local-archive :classof clos:standard-class)
(:mop-direct ql-dist:invalid-local-archive :typeof clos:standard-class)
(:mop-direct ql-dist:invalid-local-archive :superclass common-lisp:error)
(:mop-direct ql-dist:invalid-local-archive :slot
 ((:name ql-dist:release) (:ordinal 1) (:initargs (:release)) (:readers (ql-dist:invalid-local-archive-release))))
(:mop-direct ql-dist:invalid-local-archive :slot
 ((:name ql-dist::file) (:ordinal 2) (:initargs (:file)) (:readers (ql-dist:invalid-local-archive-file))))
(:mop-direct ql-dist:badly-sized-local-archive :superclass ql-dist:invalid-local-archive)
(:mop-direct ql-dist:badly-sized-local-archive :package-name "QL-DIST")
(:mop-direct ql-dist:badly-sized-local-archive :precedance
 (ql-dist:invalid-local-archive common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct ql-dist:badly-sized-local-archive :classof clos:standard-class)
(:mop-direct ql-dist:badly-sized-local-archive :typeof clos:standard-class)
(:mop-direct ql-dist:badly-sized-local-archive :superclass ql-dist:invalid-local-archive)
(:mop-direct ql-dist:badly-sized-local-archive :slot
 ((:name ql-dist::expected-size) (:ordinal 1) (:initargs (:expected-size)) (:readers (ql-dist::badly-sized-local-archive-expected-size))))
(:mop-direct ql-dist:badly-sized-local-archive :slot
 ((:name ql-dist::actual-size) (:ordinal 2) (:initargs (:actual-size)) (:readers (ql-dist::badly-sized-local-archive-actual-size))))
(:mop-direct ql-dist:badly-sized-local-archive :prototype #<ql-dist:badly-sized-local-archive #x000335A272C8>)
(:mop-direct ql-dist:missing-local-archive :superclass ql-dist:invalid-local-archive)
(:mop-direct ql-dist:missing-local-archive :package-name "QL-DIST")
(:mop-direct ql-dist:missing-local-archive :precedance
 (ql-dist:invalid-local-archive common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct ql-dist:missing-local-archive :classof clos:standard-class)
(:mop-direct ql-dist:missing-local-archive :typeof clos:standard-class)
(:mop-direct ql-dist:missing-local-archive :superclass ql-dist:invalid-local-archive)
(:mop-direct ql-dist:missing-local-archive :prototype #<ql-dist:missing-local-archive #x000335A34C18>)
(:mop-direct ql-dist:invalid-local-archive :prototype #<ql-dist:invalid-local-archive #x000335A3DBF8>)
(:mop-direct ql-dist:unknown-dist :superclass common-lisp:error)
(:mop-direct ql-dist:unknown-dist :package-name "QL-DIST")
(:mop-direct ql-dist:unknown-dist :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ql-dist:unknown-dist :classof clos:standard-class)
(:mop-direct ql-dist:unknown-dist :typeof clos:standard-class)
(:mop-direct ql-dist:unknown-dist :superclass common-lisp:error)
(:mop-direct ql-dist:unknown-dist :slot ((:name ql-dist:name) (:ordinal 1) (:initargs (:name)) (:readers (ql-dist::unknown-dist-name))))
(:mop-direct ql-dist:unknown-dist :prototype #<ql-dist:unknown-dist #x000335A4BFA8>)
(:mop-direct quicklisp-client:system-not-found :superclass common-lisp:error)
(:mop-direct quicklisp-client:system-not-found :package-name "QUICKLISP-CLIENT")
(:mop-direct quicklisp-client:system-not-found :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct quicklisp-client:system-not-found :classof clos:standard-class)
(:mop-direct quicklisp-client:system-not-found :typeof clos:standard-class)
(:mop-direct quicklisp-client:system-not-found :superclass common-lisp:error)
(:mop-direct quicklisp-client:system-not-found :slot
 ((:name ql-dist:name) (:ordinal 1) (:initargs (:name)) (:readers (quicklisp-client:system-not-found-name))))
(:mop-direct quicklisp-client:system-not-found :prototype #<quicklisp-client:system-not-found #x000335A5A7F0>)
(:mop-direct quicklisp-client::system-not-quickloadable :superclass common-lisp:error)
(:mop-direct quicklisp-client::system-not-quickloadable :package-name "QUICKLISP-CLIENT")
(:mop-direct quicklisp-client::system-not-quickloadable :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct quicklisp-client::system-not-quickloadable :classof clos:standard-class)
(:mop-direct quicklisp-client::system-not-quickloadable :typeof clos:standard-class)
(:mop-direct quicklisp-client::system-not-quickloadable :superclass common-lisp:error)
(:mop-direct quicklisp-client::system-not-quickloadable :slot
 ((:name ql-dist:system) (:ordinal 1) (:initargs (:system)) (:readers (quicklisp-client::not-quickloadable-system))))
(:mop-direct quicklisp-client::system-not-quickloadable :prototype #<quicklisp-client::system-not-quickloadable #x000335A69568>)
(:mop-direct quicklisp-client::invalid-client-file :superclass common-lisp:error)
(:mop-direct quicklisp-client::badly-sized-client-file :superclass quicklisp-client::invalid-client-file)
(:mop-direct quicklisp-client::invalid-client-file :package-name "QUICKLISP-CLIENT")
(:mop-direct quicklisp-client::invalid-client-file :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct quicklisp-client::invalid-client-file :classof clos:standard-class)
(:mop-direct quicklisp-client::invalid-client-file :typeof clos:standard-class)
(:mop-direct quicklisp-client::invalid-client-file :superclass common-lisp:error)
(:mop-direct quicklisp-client::invalid-client-file :slot
 ((:name quicklisp-client::file) (:ordinal 1) (:initargs (:file)) (:readers (quicklisp-client::invalid-client-file-file))))
(:mop-direct quicklisp-client::badly-sized-client-file :superclass quicklisp-client::invalid-client-file)
(:mop-direct quicklisp-client::badly-sized-client-file :package-name "QUICKLISP-CLIENT")
(:mop-direct quicklisp-client::badly-sized-client-file :precedance
 (quicklisp-client::invalid-client-file common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct quicklisp-client::badly-sized-client-file :classof clos:standard-class)
(:mop-direct quicklisp-client::badly-sized-client-file :typeof clos:standard-class)
(:mop-direct quicklisp-client::badly-sized-client-file :superclass quicklisp-client::invalid-client-file)
(:mop-direct quicklisp-client::badly-sized-client-file :slot
 ((:name quicklisp-client::expected-size) (:ordinal 1) (:initargs (:expected-size))
  (:readers (quicklisp-client::badly-sized-client-file-expected-size))))
(:mop-direct quicklisp-client::badly-sized-client-file :slot
 ((:name quicklisp-client::actual-size) (:ordinal 2) (:initargs (:actual-size))
  (:readers (quicklisp-client::badly-sized-client-file-actual-size))))
(:mop-direct quicklisp-client::badly-sized-client-file :prototype #<quicklisp-client::badly-sized-client-file #x000335A7D258>)
(:mop-direct quicklisp-client::invalid-client-file :prototype #<quicklisp-client::invalid-client-file #x000335A85260>)
(:mop-direct quicklisp-client::invalid-client-info :superclass common-lisp:error)
(:mop-direct quicklisp-client::invalid-client-info :package-name "QUICKLISP-CLIENT")
(:mop-direct quicklisp-client::invalid-client-info :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct quicklisp-client::invalid-client-info :classof clos:standard-class)
(:mop-direct quicklisp-client::invalid-client-info :typeof clos:standard-class)
(:mop-direct quicklisp-client::invalid-client-info :superclass common-lisp:error)
(:mop-direct quicklisp-client::invalid-client-info :slot
 ((:name quicklisp-client::plist) (:ordinal 1) (:initargs (quicklisp-client::plist)) (:readers (quicklisp-client::invalid-client-info-plist))))
(:mop-direct quicklisp-client::invalid-client-info :prototype #<quicklisp-client::invalid-client-info #x000335A8EF18>)
(:mop-direct ql-bundle::bundle-error :superclass common-lisp:error)
(:mop-direct ql-bundle:bundle-directory-exists :superclass ql-bundle::bundle-error)
(:mop-direct ql-bundle:object-not-found :superclass ql-bundle::bundle-error)
(:mop-direct ql-bundle::bundle-error :package-name "QL-BUNDLE")
(:mop-direct ql-bundle::bundle-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ql-bundle::bundle-error :classof clos:standard-class)
(:mop-direct ql-bundle::bundle-error :typeof clos:standard-class)
(:mop-direct ql-bundle::bundle-error :superclass common-lisp:error)
(:mop-direct ql-bundle:bundle-directory-exists :superclass ql-bundle::bundle-error)
(:mop-direct ql-bundle:bundle-directory-exists :package-name "QL-BUNDLE")
(:mop-direct ql-bundle:bundle-directory-exists :precedance
 (ql-bundle::bundle-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ql-bundle:bundle-directory-exists :classof clos:standard-class)
(:mop-direct ql-bundle:bundle-directory-exists :typeof clos:standard-class)
(:mop-direct ql-bundle:bundle-directory-exists :superclass ql-bundle::bundle-error)
(:mop-direct ql-bundle:bundle-directory-exists :slot
 ((:name common-lisp:directory) (:ordinal 1) (:initargs (:directory)) (:readers (ql-bundle:bundle-directory-exists-directory))))
(:mop-direct ql-bundle:bundle-directory-exists :prototype #<ql-bundle:bundle-directory-exists #x000335A9E790>)
(:mop-direct ql-bundle:object-not-found :superclass ql-bundle::bundle-error)
(:mop-direct ql-bundle:release-not-found :superclass ql-bundle:object-not-found)
(:mop-direct ql-bundle:system-not-found :superclass ql-bundle:object-not-found)
(:mop-direct ql-bundle:object-not-found :default-initargs ((:type "Object" #<compiled-function clos::constant-initfunction>)))
(:mop-direct ql-bundle:object-not-found :package-name "QL-BUNDLE")
(:mop-direct ql-bundle:object-not-found :precedance
 (ql-bundle::bundle-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct ql-bundle:object-not-found :classof clos:standard-class)
(:mop-direct ql-bundle:object-not-found :typeof clos:standard-class)
(:mop-direct ql-bundle:object-not-found :superclass ql-bundle::bundle-error)
(:mop-direct ql-bundle:object-not-found :slot
 ((:name ql-dist:name) (:ordinal 1) (:initargs (:name)) (:readers (ql-bundle::object-not-found-name))))
(:mop-direct ql-bundle:object-not-found :slot
 ((:name common-lisp:type) (:ordinal 2) (:initargs (:type)) (:readers (ql-bundle::object-not-found-type))))
(:mop-direct ql-bundle:release-not-found :superclass ql-bundle:object-not-found)
(:mop-direct ql-bundle:release-not-found :default-initargs ((:type "Release" #<compiled-function clos::constant-initfunction>)))
(:mop-direct ql-bundle:release-not-found :package-name "QL-BUNDLE")
(:mop-direct ql-bundle:release-not-found :precedance
 (ql-bundle:object-not-found ql-bundle::bundle-error common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct ql-bundle:release-not-found :classof clos:standard-class)
(:mop-direct ql-bundle:release-not-found :typeof clos:standard-class)
(:mop-direct ql-bundle:release-not-found :superclass ql-bundle:object-not-found)
(:mop-direct ql-bundle:release-not-found :prototype #<ql-bundle:release-not-found #x000335AB7B38>)
(:mop-direct ql-bundle:system-not-found :superclass ql-bundle:object-not-found)
(:mop-direct ql-bundle:system-not-found :default-initargs ((:type "System" #<compiled-function clos::constant-initfunction>)))
(:mop-direct ql-bundle:system-not-found :package-name "QL-BUNDLE")
(:mop-direct ql-bundle:system-not-found :precedance
 (ql-bundle:object-not-found ql-bundle::bundle-error common-lisp:error common-lisp:serious-condition common-lisp:condition
  common-lisp:standard-object common-lisp:t))
(:mop-direct ql-bundle:system-not-found :classof clos:standard-class)
(:mop-direct ql-bundle:system-not-found :typeof clos:standard-class)
(:mop-direct ql-bundle:system-not-found :superclass ql-bundle:object-not-found)
(:mop-direct ql-bundle:system-not-found :slot ((:name ql-dist:name) (:ordinal 1) (:readers (ql-bundle:system-not-found-system))))
(:mop-direct ql-bundle:system-not-found :prototype #<ql-bundle:system-not-found #x000335AC6E80>)
(:mop-direct ql-bundle:object-not-found :prototype #<ql-bundle:object-not-found #x000335AC97B8>)
(:mop-direct ql-bundle::bundle-error :prototype #<ql-bundle::bundle-error #x000335ACC0F0>)
(:mop-direct uiop/utility:not-implemented-error :superclass common-lisp:error)
(:mop-direct uiop/utility:not-implemented-error :package-name "UIOP/UTILITY")
(:mop-direct uiop/utility:not-implemented-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct uiop/utility:not-implemented-error :classof clos:standard-class)
(:mop-direct uiop/utility:not-implemented-error :typeof clos:standard-class)
(:mop-direct uiop/utility:not-implemented-error :superclass common-lisp:error)
(:mop-direct uiop/utility:not-implemented-error :slot ((:name uiop/utility::functionality) (:ordinal 1) (:initargs (:functionality))))
(:mop-direct uiop/utility:not-implemented-error :slot ((:name uiop/utility::format-control) (:ordinal 2) (:initargs (:format-control))))
(:mop-direct uiop/utility:not-implemented-error :slot ((:name uiop/utility::format-arguments) (:ordinal 3) (:initargs (:format-arguments))))
(:mop-direct uiop/utility:not-implemented-error :prototype #<uiop/utility:not-implemented-error #x000335AD7BD8>)
(:mop-direct uiop/utility:parameter-error :superclass common-lisp:error)
(:mop-direct uiop/utility:parameter-error :package-name "UIOP/UTILITY")
(:mop-direct uiop/utility:parameter-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct uiop/utility:parameter-error :classof clos:standard-class)
(:mop-direct uiop/utility:parameter-error :typeof clos:standard-class)
(:mop-direct uiop/utility:parameter-error :superclass common-lisp:error)
(:mop-direct uiop/utility:parameter-error :slot ((:name uiop/utility::functionality) (:ordinal 1) (:initargs (:functionality))))
(:mop-direct uiop/utility:parameter-error :slot ((:name uiop/utility::format-control) (:ordinal 2) (:initargs (:format-control))))
(:mop-direct uiop/utility:parameter-error :slot ((:name uiop/utility::format-arguments) (:ordinal 3) (:initargs (:format-arguments))))
(:mop-direct uiop/utility:parameter-error :prototype #<uiop/utility:parameter-error #x000335966F08>)
(:mop-direct uiop/version:deprecated-function-error :superclass uiop/version:deprecated-function-condition)
(:mop-direct uiop/version:deprecated-function-error :superclass common-lisp:error)
(:mop-direct uiop/version:deprecated-function-error :package-name "UIOP/VERSION")
(:mop-direct uiop/version:deprecated-function-error :precedance
 (uiop/version:deprecated-function-condition common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct uiop/version:deprecated-function-error :classof clos:standard-class)
(:mop-direct uiop/version:deprecated-function-error :typeof clos:standard-class)
(:mop-direct uiop/version:deprecated-function-error :superclass common-lisp:error)

(:mop-direct uiop/version:deprecated-function-should-be-deleted :superclass uiop/version:deprecated-function-condition)
(:mop-direct uiop/version:deprecated-function-should-be-deleted :superclass common-lisp:error)
(:mop-direct uiop/version:deprecated-function-should-be-deleted :package-name "UIOP/VERSION")
(:mop-direct uiop/version:deprecated-function-should-be-deleted :precedance
 (uiop/version:deprecated-function-condition common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct uiop/version:deprecated-function-should-be-deleted :classof clos:standard-class)
(:mop-direct uiop/version:deprecated-function-should-be-deleted :typeof clos:standard-class)
(:mop-direct uiop/version:deprecated-function-should-be-deleted :superclass common-lisp:error)

(:mop-direct uiop/lisp-build:compile-file-error :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-file-error :superclass common-lisp:error)
(:mop-direct uiop/lisp-build:compile-file-error :package-name "UIOP/LISP-BUILD")
(:mop-direct uiop/lisp-build:compile-file-error :precedance
 (uiop/lisp-build:compile-condition common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct uiop/lisp-build:compile-file-error :classof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-file-error :typeof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-file-error :superclass common-lisp:error)
(:mop-direct uiop/lisp-build:compile-file-error :prototype #<uiop/lisp-build:compile-file-error #x000335960D10>)
(:mop-direct uiop/lisp-build:compile-warned-error :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-warned-error :superclass common-lisp:error)
(:mop-direct uiop/lisp-build:compile-warned-error :package-name "UIOP/LISP-BUILD")
(:mop-direct uiop/lisp-build:compile-warned-error :precedance
 (uiop/lisp-build:compile-condition common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct uiop/lisp-build:compile-warned-error :classof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-warned-error :typeof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-warned-error :superclass common-lisp:error)
(:mop-direct uiop/lisp-build:compile-warned-error :prototype #<uiop/lisp-build:compile-warned-error #x000335960CB0>)
(:mop-direct uiop/lisp-build:compile-failed-error :superclass uiop/lisp-build:compile-condition)
(:mop-direct uiop/lisp-build:compile-failed-error :superclass common-lisp:error)
(:mop-direct uiop/lisp-build:compile-failed-error :package-name "UIOP/LISP-BUILD")
(:mop-direct uiop/lisp-build:compile-failed-error :precedance
 (uiop/lisp-build:compile-condition common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct uiop/lisp-build:compile-failed-error :classof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-failed-error :typeof clos:standard-class)
(:mop-direct uiop/lisp-build:compile-failed-error :superclass common-lisp:error)
(:mop-direct uiop/lisp-build:compile-failed-error :prototype #<uiop/lisp-build:compile-failed-error #x000335960B50>)
(:mop-direct uiop/run-program:subprocess-error :superclass common-lisp:error)
(:mop-direct uiop/run-program:subprocess-error :package-name "UIOP/RUN-PROGRAM")
(:mop-direct uiop/run-program:subprocess-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct uiop/run-program:subprocess-error :classof clos:standard-class)
(:mop-direct uiop/run-program:subprocess-error :typeof clos:standard-class)
(:mop-direct uiop/run-program:subprocess-error :superclass common-lisp:error)
(:mop-direct uiop/run-program:subprocess-error :slot
 ((:name uiop/run-program::code) (:ordinal 1) (:initargs (:code)) (:readers (uiop/run-program:subprocess-error-code))))
(:mop-direct uiop/run-program:subprocess-error :slot
 ((:name uiop/run-program::command) (:ordinal 2) (:initargs (:command)) (:readers (uiop/run-program:subprocess-error-command))))
(:mop-direct uiop/run-program:subprocess-error :slot
 ((:name uiop/run-program::process) (:ordinal 3) (:initargs (:process)) (:readers (uiop/run-program:subprocess-error-process))))
(:mop-direct uiop/run-program:subprocess-error :prototype #<uiop/run-program:subprocess-error #x0003359A1460>)
(:mop-direct asdf/session:system-definition-error :superclass common-lisp:error)
(:mop-direct asdf/package-inferred-system:package-inferred-system-missing-package-error :superclass asdf/session:system-definition-error)
(:mop-direct asdf/parse-defsystem:non-toplevel-system :superclass asdf/session:system-definition-error)
(:mop-direct asdf/parse-defsystem:non-system-system :superclass asdf/session:system-definition-error)
(:mop-direct asdf/find-system:load-system-definition-error :superclass asdf/session:system-definition-error)
(:mop-direct asdf/find-component:missing-component :superclass asdf/session:system-definition-error)
(:mop-direct asdf/action:circular-dependency :superclass asdf/session:system-definition-error)
(:mop-direct asdf/component:duplicate-names :superclass asdf/session:system-definition-error)
(:mop-direct asdf/session:formatted-system-definition-error :superclass asdf/session:system-definition-error)
(:mop-direct asdf/session:system-definition-error :package-name "ASDF/SESSION")
(:mop-direct asdf/session:system-definition-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/session:system-definition-error :classof clos:standard-class)
(:mop-direct asdf/session:system-definition-error :typeof clos:standard-class)
(:mop-direct asdf/session:system-definition-error :superclass common-lisp:error)
(:mop-direct asdf/package-inferred-system:package-inferred-system-missing-package-error :superclass asdf/session:system-definition-error)
(:mop-direct asdf/package-inferred-system:package-inferred-system-missing-package-error :package-name "ASDF/PACKAGE-INFERRED-SYSTEM")
(:mop-direct asdf/package-inferred-system:package-inferred-system-missing-package-error :precedance
 (asdf/session:system-definition-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf/package-inferred-system:package-inferred-system-missing-package-error :classof clos:standard-class)
(:mop-direct asdf/package-inferred-system:package-inferred-system-missing-package-error :typeof clos:standard-class)
(:mop-direct asdf/package-inferred-system:package-inferred-system-missing-package-error :superclass asdf/session:system-definition-error)
(:mop-direct asdf/package-inferred-system:package-inferred-system-missing-package-error :slot
 ((:name asdf/system:system) (:ordinal 1) (:initargs (:system)) (:readers (asdf/package-inferred-system::error-system))))
(:mop-direct asdf/package-inferred-system:package-inferred-system-missing-package-error :slot
 ((:name common-lisp:pathname) (:ordinal 2) (:initargs (:pathname)) (:readers (asdf/package-inferred-system::error-pathname))))
(:mop-direct asdf/package-inferred-system:package-inferred-system-missing-package-error :prototype
 #<asdf/package-inferred-system:package-inferred-system-missing-package-error #x0003359BF010>)
(:mop-direct asdf/parse-defsystem:non-toplevel-system :superclass asdf/session:system-definition-error)
(:mop-direct asdf/parse-defsystem:non-toplevel-system :package-name "ASDF/PARSE-DEFSYSTEM")
(:mop-direct asdf/parse-defsystem:non-toplevel-system :precedance
 (asdf/session:system-definition-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf/parse-defsystem:non-toplevel-system :classof clos:standard-class)
(:mop-direct asdf/parse-defsystem:non-toplevel-system :typeof clos:standard-class)
(:mop-direct asdf/parse-defsystem:non-toplevel-system :superclass asdf/session:system-definition-error)
(:mop-direct asdf/parse-defsystem:non-toplevel-system :slot
 ((:name asdf/component:parent) (:ordinal 1) (:initargs (:parent)) (:readers (asdf/parse-defsystem::non-toplevel-system-parent))))
(:mop-direct asdf/parse-defsystem:non-toplevel-system :slot
 ((:name asdf/component:name) (:ordinal 2) (:initargs (:name)) (:readers (asdf/parse-defsystem::non-toplevel-system-name))))
(:mop-direct asdf/parse-defsystem:non-toplevel-system :prototype #<asdf/parse-defsystem:non-toplevel-system #x0003359D1230>)
(:mop-direct asdf/parse-defsystem:non-system-system :superclass asdf/session:system-definition-error)
(:mop-direct asdf/parse-defsystem:non-system-system :package-name "ASDF/PARSE-DEFSYSTEM")
(:mop-direct asdf/parse-defsystem:non-system-system :precedance
 (asdf/session:system-definition-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf/parse-defsystem:non-system-system :classof clos:standard-class)
(:mop-direct asdf/parse-defsystem:non-system-system :typeof clos:standard-class)
(:mop-direct asdf/parse-defsystem:non-system-system :superclass asdf/session:system-definition-error)
(:mop-direct asdf/parse-defsystem:non-system-system :slot
 ((:name asdf/component:name) (:ordinal 1) (:initargs (:name)) (:readers (asdf/parse-defsystem::non-system-system-name))))
(:mop-direct asdf/parse-defsystem:non-system-system :slot
 ((:name clos:class-name) (:ordinal 2) (:initargs (:class-name)) (:readers (asdf/parse-defsystem::non-system-system-class-name))))
(:mop-direct asdf/parse-defsystem:non-system-system :prototype #<asdf/parse-defsystem:non-system-system #x0003359E3328>)
(:mop-direct asdf/find-system:load-system-definition-error :superclass asdf/session:system-definition-error)
(:mop-direct asdf/find-system:load-system-definition-error :package-name "ASDF/FIND-SYSTEM")
(:mop-direct asdf/find-system:load-system-definition-error :precedance
 (asdf/session:system-definition-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf/find-system:load-system-definition-error :classof clos:standard-class)
(:mop-direct asdf/find-system:load-system-definition-error :typeof clos:standard-class)
(:mop-direct asdf/find-system:load-system-definition-error :superclass asdf/session:system-definition-error)
(:mop-direct asdf/find-system:load-system-definition-error :slot
 ((:name asdf/component:name) (:ordinal 1) (:initargs (:name)) (:readers (asdf/find-system:error-name))))
(:mop-direct asdf/find-system:load-system-definition-error :slot
 ((:name common-lisp:pathname) (:ordinal 2) (:initargs (:pathname)) (:readers (asdf/find-system:error-pathname))))
(:mop-direct asdf/find-system:load-system-definition-error :slot
 ((:name common-lisp:condition) (:ordinal 3) (:initargs (:condition)) (:readers (asdf/find-system:error-condition))))
(:mop-direct asdf/find-system:load-system-definition-error :prototype #<asdf/find-system:load-system-definition-error #x0003359F7080>)
(:mop-direct asdf/find-component:missing-component :superclass asdf/session:system-definition-error)
(:mop-direct asdf/find-component:missing-dependency :superclass asdf/find-component:missing-component)
(:mop-direct asdf/find-component:missing-component-of-version :superclass asdf/find-component:missing-component)
(:mop-direct asdf/find-component:missing-component :package-name "ASDF/FIND-COMPONENT")
(:mop-direct asdf/find-component:missing-component :precedance
 (asdf/session:system-definition-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf/find-component:missing-component :classof clos:standard-class)
(:mop-direct asdf/find-component:missing-component :typeof clos:standard-class)
(:mop-direct asdf/find-component:missing-component :superclass asdf/session:system-definition-error)
(:mop-direct asdf/find-component:missing-component :slot
 ((:name asdf/find-component::requires) (:ordinal 1) (:initform "(unnamed)") (:initargs (:requires))
  (:readers (asdf/find-component:missing-requires))))
(:mop-direct asdf/find-component:missing-component :slot
 ((:name asdf/component:parent) (:ordinal 2) (:initargs (:parent)) (:readers (asdf/find-component:missing-parent))))
(:mop-direct asdf/find-component:missing-dependency :superclass asdf/find-component:missing-component)
(:mop-direct asdf/find-component:missing-dependency-of-version :superclass asdf/find-component:missing-dependency)
(:mop-direct asdf/find-component:missing-dependency :package-name "ASDF/FIND-COMPONENT")
(:mop-direct asdf/find-component:missing-dependency :precedance
 (asdf/find-component:missing-component asdf/session:system-definition-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/find-component:missing-dependency :classof clos:standard-class)
(:mop-direct asdf/find-component:missing-dependency :typeof clos:standard-class)
(:mop-direct asdf/find-component:missing-dependency :superclass asdf/find-component:missing-component)
(:mop-direct asdf/find-component:missing-dependency :slot
 ((:name asdf/find-component::required-by) (:ordinal 1) (:initargs (:required-by)) (:readers (asdf/find-component:missing-required-by))))
(:mop-direct asdf/find-component:missing-dependency-of-version :superclass asdf/find-component:missing-dependency)
(:mop-direct asdf/find-component:missing-dependency-of-version :superclass asdf/find-component:missing-component-of-version)
(:mop-direct asdf/find-component:missing-dependency-of-version :package-name "ASDF/FIND-COMPONENT")
(:mop-direct asdf/find-component:missing-dependency-of-version :precedance
 (asdf/find-component:missing-dependency asdf/find-component:missing-component-of-version asdf/find-component:missing-component
  asdf/session:system-definition-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf/find-component:missing-dependency-of-version :classof clos:standard-class)
(:mop-direct asdf/find-component:missing-dependency-of-version :typeof clos:standard-class)
(:mop-direct asdf/find-component:missing-dependency-of-version :superclass asdf/find-component:missing-dependency)


(:mop-direct asdf/find-component:missing-component-of-version :superclass asdf/find-component:missing-component)
(:mop-direct asdf/find-component:missing-dependency-of-version :superclass asdf/find-component:missing-component-of-version)
(:mop-direct asdf/find-component:missing-component-of-version :package-name "ASDF/FIND-COMPONENT")
(:mop-direct asdf/find-component:missing-component-of-version :precedance
 (asdf/find-component:missing-component asdf/session:system-definition-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/find-component:missing-component-of-version :classof clos:standard-class)
(:mop-direct asdf/find-component:missing-component-of-version :typeof clos:standard-class)
(:mop-direct asdf/find-component:missing-component-of-version :superclass asdf/find-component:missing-component)
(:mop-direct asdf/find-component:missing-component-of-version :slot
 ((:name asdf/component:version) (:ordinal 1) (:initargs (:version)) (:readers (asdf/find-component:missing-version))))
(:mop-direct asdf/find-component:missing-dependency-of-version :superclass asdf/find-component:missing-dependency)
(:mop-direct asdf/find-component:missing-dependency-of-version :superclass asdf/find-component:missing-component-of-version)
(:mop-direct asdf/find-component:missing-dependency-of-version :package-name "ASDF/FIND-COMPONENT")
(:mop-direct asdf/find-component:missing-dependency-of-version :precedance
 (asdf/find-component:missing-dependency asdf/find-component:missing-component-of-version asdf/find-component:missing-component
  asdf/session:system-definition-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf/find-component:missing-dependency-of-version :classof clos:standard-class)
(:mop-direct asdf/find-component:missing-dependency-of-version :typeof clos:standard-class)
(:mop-direct asdf/find-component:missing-dependency-of-version :superclass asdf/find-component:missing-component-of-version)



(:mop-direct asdf/action:circular-dependency :superclass asdf/session:system-definition-error)
(:mop-direct asdf/action:circular-dependency :package-name "ASDF/ACTION")
(:mop-direct asdf/action:circular-dependency :precedance
 (asdf/session:system-definition-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf/action:circular-dependency :classof clos:standard-class)
(:mop-direct asdf/action:circular-dependency :typeof clos:standard-class)
(:mop-direct asdf/action:circular-dependency :superclass asdf/session:system-definition-error)
(:mop-direct asdf/action:circular-dependency :slot
 ((:name asdf/action::actions) (:ordinal 1) (:initargs (:actions)) (:readers (asdf/action:circular-dependency-actions))))
(:mop-direct asdf/action:circular-dependency :prototype #<asdf/action:circular-dependency #x000335A5B6E8>)
(:mop-direct asdf/component:duplicate-names :superclass asdf/session:system-definition-error)
(:mop-direct asdf/component:duplicate-names :package-name "ASDF/COMPONENT")
(:mop-direct asdf/component:duplicate-names :precedance
 (asdf/session:system-definition-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf/component:duplicate-names :classof clos:standard-class)
(:mop-direct asdf/component:duplicate-names :typeof clos:standard-class)
(:mop-direct asdf/component:duplicate-names :superclass asdf/session:system-definition-error)
(:mop-direct asdf/component:duplicate-names :slot
 ((:name asdf/component:name) (:ordinal 1) (:initargs (:name)) (:readers (asdf/component::duplicate-names-name))))
(:mop-direct asdf/component:duplicate-names :prototype #<asdf/component:duplicate-names #x000335A6D718>)
(:mop-direct asdf/session:formatted-system-definition-error :superclass asdf/session:system-definition-error)
(:mop-direct asdf/session:formatted-system-definition-error :package-name "ASDF/SESSION")
(:mop-direct asdf/session:formatted-system-definition-error :precedance
 (asdf/session:system-definition-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf/session:formatted-system-definition-error :classof clos:standard-class)
(:mop-direct asdf/session:formatted-system-definition-error :typeof clos:standard-class)
(:mop-direct asdf/session:formatted-system-definition-error :superclass asdf/session:system-definition-error)
(:mop-direct asdf/session:formatted-system-definition-error :slot
 ((:name asdf/session:format-control) (:ordinal 1) (:initargs (:format-control)) (:readers (asdf/session:format-control))))
(:mop-direct asdf/session:formatted-system-definition-error :slot
 ((:name asdf/session:format-arguments) (:ordinal 2) (:initargs (:format-arguments)) (:readers (asdf/session:format-arguments))))
(:mop-direct asdf/session:formatted-system-definition-error :prototype #<asdf/session:formatted-system-definition-error #x000335A7F190>)
(:mop-direct asdf/session:system-definition-error :prototype #<asdf/session:system-definition-error #x000335A87908>)
(:mop-direct asdf/backward-interface:operation-error :superclass common-lisp:error)
(:mop-direct asdf/backward-interface:compile-error :superclass asdf/backward-interface:operation-error)
(:mop-direct asdf/backward-interface:operation-error :package-name "ASDF/BACKWARD-INTERFACE")
(:mop-direct asdf/backward-interface:operation-error :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/backward-interface:operation-error :classof clos:standard-class)
(:mop-direct asdf/backward-interface:operation-error :typeof clos:standard-class)
(:mop-direct asdf/backward-interface:operation-error :superclass common-lisp:error)
(:mop-direct asdf/backward-interface:operation-error :slot
 ((:name asdf/component:component) (:ordinal 1) (:initargs (:component)) (:readers (asdf/backward-interface:error-component))))
(:mop-direct asdf/backward-interface:operation-error :slot
 ((:name asdf/operation:operation) (:ordinal 2) (:initargs (:operation)) (:readers (asdf/backward-interface:error-operation))))
(:mop-direct asdf/backward-interface:compile-error :superclass asdf/backward-interface:operation-error)
(:mop-direct asdf/backward-interface:compile-warned :superclass asdf/backward-interface:compile-error)
(:mop-direct asdf/backward-interface:compile-failed :superclass asdf/backward-interface:compile-error)
(:mop-direct asdf/backward-interface:compile-error :package-name "ASDF/BACKWARD-INTERFACE")
(:mop-direct asdf/backward-interface:compile-error :precedance
 (asdf/backward-interface:operation-error common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf/backward-interface:compile-error :classof clos:standard-class)
(:mop-direct asdf/backward-interface:compile-error :typeof clos:standard-class)
(:mop-direct asdf/backward-interface:compile-error :superclass asdf/backward-interface:operation-error)
(:mop-direct asdf/backward-interface:compile-warned :superclass asdf/backward-interface:compile-error)
(:mop-direct asdf/backward-interface:compile-warned :package-name "ASDF/BACKWARD-INTERFACE")
(:mop-direct asdf/backward-interface:compile-warned :precedance
 (asdf/backward-interface:compile-error asdf/backward-interface:operation-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/backward-interface:compile-warned :classof clos:standard-class)
(:mop-direct asdf/backward-interface:compile-warned :typeof clos:standard-class)
(:mop-direct asdf/backward-interface:compile-warned :superclass asdf/backward-interface:compile-error)
(:mop-direct asdf/backward-interface:compile-warned :prototype #<asdf/backward-interface:compile-warned #x000335A9FEB0>)
(:mop-direct asdf/backward-interface:compile-failed :superclass asdf/backward-interface:compile-error)
(:mop-direct asdf/backward-interface:compile-failed :package-name "ASDF/BACKWARD-INTERFACE")
(:mop-direct asdf/backward-interface:compile-failed :precedance
 (asdf/backward-interface:compile-error asdf/backward-interface:operation-error common-lisp:error common-lisp:serious-condition
  common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/backward-interface:compile-failed :classof clos:standard-class)
(:mop-direct asdf/backward-interface:compile-failed :typeof clos:standard-class)
(:mop-direct asdf/backward-interface:compile-failed :superclass asdf/backward-interface:compile-error)
(:mop-direct asdf/backward-interface:compile-failed :prototype #<asdf/backward-interface:compile-failed #x000335AAD6F0>)
(:mop-direct asdf/backward-interface:compile-error :prototype #<asdf/backward-interface:compile-error #x000335AB0C70>)
(:mop-direct asdf/backward-interface:operation-error :prototype #<asdf/backward-interface:operation-error #x000335AB41F0>)
(:mop-direct qlqs-http::match-failure :superclass common-lisp:error)
(:mop-direct qlqs-http::match-failure :package-name "QLQS-HTTP")
(:mop-direct qlqs-http::match-failure :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-http::match-failure :classof clos:standard-class)
(:mop-direct qlqs-http::match-failure :typeof clos:standard-class)
(:mop-direct qlqs-http::match-failure :superclass common-lisp:error)
(:mop-direct qlqs-http::match-failure :prototype #<qlqs-http::match-failure #x000335ABBEE8>)
(:mop-direct qlqs-http::end-of-data :superclass common-lisp:error)
(:mop-direct qlqs-http::end-of-data :package-name "QLQS-HTTP")
(:mop-direct qlqs-http::end-of-data :precedance
 (common-lisp:error common-lisp:serious-condition common-lisp:condition common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-http::end-of-data :classof clos:standard-class)
(:mop-direct qlqs-http::end-of-data :typeof clos:standard-class)
(:mop-direct qlqs-http::end-of-data :superclass common-lisp:error)
(:mop-direct qlqs-http::end-of-data :prototype #<qlqs-http::end-of-data #x000335AC2F88>)
(:mop-direct common-lisp:error :prototype #<common-lisp:error #x000335AC58B0>)
(:mop-direct common-lisp:serious-condition :prototype #<common-lisp:serious-condition #x000335AC81D8>)
(:mop-direct common-lisp:condition :prototype #<common-lisp:condition #x000335ACAE30>)
(:mop-direct gray:fundamental-stream :superclass common-lisp:stream)
(:mop-direct gray:fundamental-stream :superclass common-lisp:standard-object)
(:mop-direct gray:fundamental-binary-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-character-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-output-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-input-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-stream :package-name "GRAY")
(:mop-direct gray:fundamental-stream :precedance (common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct gray:fundamental-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-stream :superclass common-lisp:standard-object)
(:mop-direct gray:fundamental-stream :slot ((:name system::$open) (:ordinal 1) (:initform common-lisp:t) (:type common-lisp:boolean)))
(:mop-direct gray:fundamental-stream :slot ((:name system::$fasl) (:ordinal 2) (:type common-lisp:boolean)))
(:mop-direct gray:fundamental-stream :slot ((:name system::$penl) (:ordinal 3) (:type common-lisp:boolean)))
(:mop-direct gray:fundamental-binary-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-binary-output-stream :superclass gray:fundamental-binary-stream)
(:mop-direct gray:fundamental-binary-input-stream :superclass gray:fundamental-binary-stream)
(:mop-direct gray:fundamental-binary-stream :package-name "GRAY")
(:mop-direct gray:fundamental-binary-stream :precedance (gray:fundamental-stream common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct gray:fundamental-binary-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-binary-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-binary-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-binary-output-stream :superclass gray:fundamental-output-stream)
(:mop-direct gray:fundamental-binary-output-stream :superclass gray:fundamental-binary-stream)
(:mop-direct gray:fundamental-binary-output-stream :package-name "GRAY")
(:mop-direct gray:fundamental-binary-output-stream :precedance
 (gray:fundamental-output-stream gray:fundamental-binary-stream gray:fundamental-stream common-lisp:stream common-lisp:standard-object
  common-lisp:t))
(:mop-direct gray:fundamental-binary-output-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-binary-output-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-binary-output-stream :superclass gray:fundamental-binary-stream)
(:mop-direct gray:fundamental-binary-output-stream :prototype #<gray:fundamental-binary-output-stream #x00033595E238>)
(:mop-direct gray:fundamental-binary-input-stream :superclass gray:fundamental-input-stream)
(:mop-direct gray:fundamental-binary-input-stream :superclass gray:fundamental-binary-stream)
(:mop-direct gray:fundamental-binary-input-stream :package-name "GRAY")
(:mop-direct gray:fundamental-binary-input-stream :precedance
 (gray:fundamental-input-stream gray:fundamental-binary-stream gray:fundamental-stream common-lisp:stream common-lisp:standard-object
  common-lisp:t))
(:mop-direct gray:fundamental-binary-input-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-binary-input-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-binary-input-stream :superclass gray:fundamental-binary-stream)
(:mop-direct gray:fundamental-binary-input-stream :prototype #<gray:fundamental-binary-input-stream #x00033595E360>)
(:mop-direct gray:fundamental-binary-stream :prototype #<gray:fundamental-binary-stream #x00033595E390>)
(:mop-direct gray:fundamental-character-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-character-output-stream :superclass gray:fundamental-character-stream)
(:mop-direct gray:fundamental-character-input-stream :superclass gray:fundamental-character-stream)
(:mop-direct gray:fundamental-character-stream :package-name "GRAY")
(:mop-direct gray:fundamental-character-stream :precedance
 (gray:fundamental-stream common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct gray:fundamental-character-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-character-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-character-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-character-output-stream :superclass gray:fundamental-output-stream)
(:mop-direct gray:fundamental-character-output-stream :superclass gray:fundamental-character-stream)
(:mop-direct system::html-stream-out :superclass gray:fundamental-character-output-stream)
(:mop-direct ext:fill-stream :superclass gray:fundamental-character-output-stream)
(:mop-direct gray:fundamental-character-output-stream :package-name "GRAY")
(:mop-direct gray:fundamental-character-output-stream :precedance
 (gray:fundamental-output-stream gray:fundamental-character-stream gray:fundamental-stream common-lisp:stream common-lisp:standard-object
  common-lisp:t))
(:mop-direct gray:fundamental-character-output-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-character-output-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-character-output-stream :superclass gray:fundamental-character-stream)
(:mop-direct system::html-stream-out :superclass gray:fundamental-character-output-stream)
(:mop-direct system::html-stream-out :package-name "SYSTEM")
(:mop-direct system::html-stream-out :precedance
 (gray:fundamental-character-output-stream gray:fundamental-output-stream gray:fundamental-character-stream gray:fundamental-stream
  common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct system::html-stream-out :classof clos:standard-class)
(:mop-direct system::html-stream-out :typeof clos:standard-class)
(:mop-direct system::html-stream-out :superclass gray:fundamental-character-output-stream)
(:mop-direct system::html-stream-out :slot ((:name system::target-stream) (:ordinal 1) (:type common-lisp:stream) (:initargs (:stream))))
(:mop-direct system::html-stream-out :prototype #<system::html-stream-out #x00033595E3C0>)
(:mop-direct ext:fill-stream :superclass gray:fundamental-character-output-stream)
(:mop-direct system::describe-stream :superclass ext:fill-stream)
(:mop-direct ext:fill-stream :package-name "EXT")
(:mop-direct ext:fill-stream :precedance
 (gray:fundamental-character-output-stream gray:fundamental-output-stream gray:fundamental-character-stream gray:fundamental-stream
  common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct ext:fill-stream :classof clos:standard-class)
(:mop-direct ext:fill-stream :typeof clos:standard-class)
(:mop-direct ext:fill-stream :superclass gray:fundamental-character-output-stream)
(:mop-direct ext:fill-stream :slot ((:name system::target-stream) (:ordinal 1) (:type common-lisp:stream) (:initargs (:stream))))
(:mop-direct ext:fill-stream :slot
 ((:name system::buffer) (:ordinal 2)
  (:initform (common-lisp:make-array (system::right-margin) :element-type 'common-lisp:character :fill-pointer 0 :adjustable common-lisp:t))
  (:type common-lisp:string)))
(:mop-direct ext:fill-stream :slot ((:name system::inside-sexp) (:ordinal 3) (:type common-lisp:boolean)))
(:mop-direct ext:fill-stream :slot
 ((:name system::sexp-indent) (:ordinal 4) (:initform custom:*fill-indent-sexp*)
  (:type (common-lisp:or common-lisp:symbol common-lisp:integer common-lisp:function)) (:initargs (:sexp-indent))))
(:mop-direct ext:fill-stream :slot
 ((:name system::indent-var) (:ordinal 5) (:initform 0) (:type (common-lisp:or common-lisp:symbol common-lisp:integer))
  (:initargs (:text-indent))))
(:mop-direct ext:fill-stream :slot ((:name system::pending-space) (:ordinal 6) (:type common-lisp:boolean)))
(:mop-direct ext:fill-stream :slot ((:name system::current-indent) (:ordinal 7) (:initform 0) (:type common-lisp:integer)))
(:mop-direct ext:fill-stream :slot ((:name system::pending-indent) (:ordinal 8) (:type (common-lisp:or common-lisp:null common-lisp:integer))))
(:mop-direct system::describe-stream :superclass ext:fill-stream)
(:mop-direct system::describe-stream :package-name "SYSTEM")
(:mop-direct system::describe-stream :precedance
 (ext:fill-stream gray:fundamental-character-output-stream gray:fundamental-output-stream gray:fundamental-character-stream
  gray:fundamental-stream common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct system::describe-stream :classof clos:standard-class)
(:mop-direct system::describe-stream :typeof clos:standard-class)
(:mop-direct system::describe-stream :superclass ext:fill-stream)
(:mop-direct system::describe-stream :prototype #<system::describe-stream #x00033595E3F8>)
(:mop-direct ext:fill-stream :prototype #<ext:fill-stream #x00033595E468>)
(:mop-direct gray:fundamental-character-output-stream :prototype #<gray:fundamental-character-output-stream #x00033595E4D8>)
(:mop-direct gray:fundamental-character-input-stream :superclass gray:fundamental-input-stream)
(:mop-direct gray:fundamental-character-input-stream :superclass gray:fundamental-character-stream)
(:mop-direct gray:fundamental-character-input-stream :package-name "GRAY")
(:mop-direct gray:fundamental-character-input-stream :precedance
 (gray:fundamental-input-stream gray:fundamental-character-stream gray:fundamental-stream common-lisp:stream common-lisp:standard-object
  common-lisp:t))
(:mop-direct gray:fundamental-character-input-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-character-input-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-character-input-stream :superclass gray:fundamental-character-stream)
(:mop-direct gray:fundamental-character-input-stream :slot ((:name system::$lastchar) (:ordinal 1)))
(:mop-direct gray:fundamental-character-input-stream :prototype #<gray:fundamental-character-input-stream #x00033595E508>)
(:mop-direct gray:fundamental-character-stream :prototype #<gray:fundamental-character-stream #x00033595E540>)
(:mop-direct gray:fundamental-output-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-binary-output-stream :superclass gray:fundamental-output-stream)
(:mop-direct gray:fundamental-character-output-stream :superclass gray:fundamental-output-stream)
(:mop-direct gray:fundamental-output-stream :package-name "GRAY")
(:mop-direct gray:fundamental-output-stream :precedance (gray:fundamental-stream common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct gray:fundamental-output-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-output-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-output-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-binary-output-stream :superclass gray:fundamental-output-stream)
(:mop-direct gray:fundamental-binary-output-stream :superclass gray:fundamental-binary-stream)
(:mop-direct gray:fundamental-binary-output-stream :package-name "GRAY")
(:mop-direct gray:fundamental-binary-output-stream :precedance
 (gray:fundamental-output-stream gray:fundamental-binary-stream gray:fundamental-stream common-lisp:stream common-lisp:standard-object
  common-lisp:t))
(:mop-direct gray:fundamental-binary-output-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-binary-output-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-binary-output-stream :superclass gray:fundamental-output-stream)
(:mop-direct gray:fundamental-binary-output-stream :prototype #<gray:fundamental-binary-output-stream #x00033595E238>)
(:mop-direct gray:fundamental-character-output-stream :superclass gray:fundamental-output-stream)
(:mop-direct gray:fundamental-character-output-stream :superclass gray:fundamental-character-stream)
(:mop-direct system::html-stream-out :superclass gray:fundamental-character-output-stream)
(:mop-direct ext:fill-stream :superclass gray:fundamental-character-output-stream)
(:mop-direct gray:fundamental-character-output-stream :package-name "GRAY")
(:mop-direct gray:fundamental-character-output-stream :precedance
 (gray:fundamental-output-stream gray:fundamental-character-stream gray:fundamental-stream common-lisp:stream common-lisp:standard-object
  common-lisp:t))
(:mop-direct gray:fundamental-character-output-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-character-output-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-character-output-stream :superclass gray:fundamental-output-stream)
(:mop-direct system::html-stream-out :superclass gray:fundamental-character-output-stream)
(:mop-direct system::html-stream-out :package-name "SYSTEM")
(:mop-direct system::html-stream-out :precedance
 (gray:fundamental-character-output-stream gray:fundamental-output-stream gray:fundamental-character-stream gray:fundamental-stream
  common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct system::html-stream-out :classof clos:standard-class)
(:mop-direct system::html-stream-out :typeof clos:standard-class)
(:mop-direct system::html-stream-out :superclass gray:fundamental-character-output-stream)
(:mop-direct system::html-stream-out :slot ((:name system::target-stream) (:ordinal 1) (:type common-lisp:stream) (:initargs (:stream))))
(:mop-direct system::html-stream-out :prototype #<system::html-stream-out #x00033595E3C0>)
(:mop-direct ext:fill-stream :superclass gray:fundamental-character-output-stream)
(:mop-direct system::describe-stream :superclass ext:fill-stream)
(:mop-direct ext:fill-stream :package-name "EXT")
(:mop-direct ext:fill-stream :precedance
 (gray:fundamental-character-output-stream gray:fundamental-output-stream gray:fundamental-character-stream gray:fundamental-stream
  common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct ext:fill-stream :classof clos:standard-class)
(:mop-direct ext:fill-stream :typeof clos:standard-class)
(:mop-direct ext:fill-stream :superclass gray:fundamental-character-output-stream)
(:mop-direct ext:fill-stream :slot ((:name system::target-stream) (:ordinal 1) (:type common-lisp:stream) (:initargs (:stream))))
(:mop-direct ext:fill-stream :slot
 ((:name system::buffer) (:ordinal 2)
  (:initform (common-lisp:make-array (system::right-margin) :element-type 'common-lisp:character :fill-pointer 0 :adjustable common-lisp:t))
  (:type common-lisp:string)))
(:mop-direct ext:fill-stream :slot ((:name system::inside-sexp) (:ordinal 3) (:type common-lisp:boolean)))
(:mop-direct ext:fill-stream :slot
 ((:name system::sexp-indent) (:ordinal 4) (:initform custom:*fill-indent-sexp*)
  (:type (common-lisp:or common-lisp:symbol common-lisp:integer common-lisp:function)) (:initargs (:sexp-indent))))
(:mop-direct ext:fill-stream :slot
 ((:name system::indent-var) (:ordinal 5) (:initform 0) (:type (common-lisp:or common-lisp:symbol common-lisp:integer))
  (:initargs (:text-indent))))
(:mop-direct ext:fill-stream :slot ((:name system::pending-space) (:ordinal 6) (:type common-lisp:boolean)))
(:mop-direct ext:fill-stream :slot ((:name system::current-indent) (:ordinal 7) (:initform 0) (:type common-lisp:integer)))
(:mop-direct ext:fill-stream :slot ((:name system::pending-indent) (:ordinal 8) (:type (common-lisp:or common-lisp:null common-lisp:integer))))
(:mop-direct system::describe-stream :superclass ext:fill-stream)
(:mop-direct system::describe-stream :package-name "SYSTEM")
(:mop-direct system::describe-stream :precedance
 (ext:fill-stream gray:fundamental-character-output-stream gray:fundamental-output-stream gray:fundamental-character-stream
  gray:fundamental-stream common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct system::describe-stream :classof clos:standard-class)
(:mop-direct system::describe-stream :typeof clos:standard-class)
(:mop-direct system::describe-stream :superclass ext:fill-stream)
(:mop-direct system::describe-stream :prototype #<system::describe-stream #x00033595E3F8>)
(:mop-direct ext:fill-stream :prototype #<ext:fill-stream #x00033595E468>)
(:mop-direct gray:fundamental-character-output-stream :prototype #<gray:fundamental-character-output-stream #x00033595E4D8>)
(:mop-direct gray:fundamental-output-stream :prototype #<gray:fundamental-output-stream #x00033595E570>)
(:mop-direct gray:fundamental-input-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-binary-input-stream :superclass gray:fundamental-input-stream)
(:mop-direct gray:fundamental-character-input-stream :superclass gray:fundamental-input-stream)
(:mop-direct gray:fundamental-input-stream :package-name "GRAY")
(:mop-direct gray:fundamental-input-stream :precedance (gray:fundamental-stream common-lisp:stream common-lisp:standard-object common-lisp:t))
(:mop-direct gray:fundamental-input-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-input-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-input-stream :superclass gray:fundamental-stream)
(:mop-direct gray:fundamental-binary-input-stream :superclass gray:fundamental-input-stream)
(:mop-direct gray:fundamental-binary-input-stream :superclass gray:fundamental-binary-stream)
(:mop-direct gray:fundamental-binary-input-stream :package-name "GRAY")
(:mop-direct gray:fundamental-binary-input-stream :precedance
 (gray:fundamental-input-stream gray:fundamental-binary-stream gray:fundamental-stream common-lisp:stream common-lisp:standard-object
  common-lisp:t))
(:mop-direct gray:fundamental-binary-input-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-binary-input-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-binary-input-stream :superclass gray:fundamental-input-stream)
(:mop-direct gray:fundamental-binary-input-stream :prototype #<gray:fundamental-binary-input-stream #x00033595E360>)
(:mop-direct gray:fundamental-character-input-stream :superclass gray:fundamental-input-stream)
(:mop-direct gray:fundamental-character-input-stream :superclass gray:fundamental-character-stream)
(:mop-direct gray:fundamental-character-input-stream :package-name "GRAY")
(:mop-direct gray:fundamental-character-input-stream :precedance
 (gray:fundamental-input-stream gray:fundamental-character-stream gray:fundamental-stream common-lisp:stream common-lisp:standard-object
  common-lisp:t))
(:mop-direct gray:fundamental-character-input-stream :classof clos:standard-class)
(:mop-direct gray:fundamental-character-input-stream :typeof clos:standard-class)
(:mop-direct gray:fundamental-character-input-stream :superclass gray:fundamental-input-stream)
(:mop-direct gray:fundamental-character-input-stream :slot ((:name system::$lastchar) (:ordinal 1)))
(:mop-direct gray:fundamental-character-input-stream :prototype #<gray:fundamental-character-input-stream #x00033595E508>)
(:mop-direct gray:fundamental-input-stream :prototype #<gray:fundamental-input-stream #x00033595E5A0>)
(:mop-direct gray:fundamental-stream :prototype #<gray:fundamental-stream #x00033595E5D0>)
(:mop-direct clos:funcallable-standard-object :superclass common-lisp:function)
(:mop-direct clos:funcallable-standard-object :superclass common-lisp:standard-object)
(:mop-direct clos:generic-function :superclass clos:funcallable-standard-object)
(:mop-direct clos:funcallable-standard-object :package-name "CLOS")
(:mop-direct clos:funcallable-standard-object :precedance (common-lisp:function common-lisp:standard-object common-lisp:t))
(:mop-direct clos:funcallable-standard-object :classof clos:funcallable-standard-class)
(:mop-direct clos:funcallable-standard-object :typeof clos:funcallable-standard-class)
(:mop-direct clos:funcallable-standard-object :superclass common-lisp:standard-object)
(:mop-direct clos:funcallable-standard-object :slot
 ((:name clos::$name) (:ordinal 1) (:readers (clos::funcallable-name)) (:writers ((common-lisp:setf clos::funcallable-name)))))
(:mop-direct clos:generic-function :superclass clos:metaobject)
(:mop-direct clos:generic-function :superclass clos:funcallable-standard-object)
(:mop-direct clos:standard-generic-function :superclass clos:generic-function)
(:mop-direct clos:generic-function :package-name "CLOS")
(:mop-direct clos:generic-function :precedance
 (clos:metaobject clos:funcallable-standard-object common-lisp:function common-lisp:standard-object common-lisp:t))
(:mop-direct clos:generic-function :classof clos:funcallable-standard-class)
(:mop-direct clos:generic-function :typeof clos:funcallable-standard-class)
(:mop-direct clos:generic-function :superclass clos:funcallable-standard-object)
(:mop-direct clos:generic-function :slot
 ((:name clos::$listeners) (:ordinal 1) (:type common-lisp:list) (:readers (clos::gf-listeners))
  (:writers ((common-lisp:setf clos::gf-listeners)))))
(:mop-direct clos:standard-generic-function :superclass clos:generic-function)
(:mop-direct closer-mop:standard-generic-function :superclass clos:standard-generic-function)
(:mop-direct clos:standard-generic-function :package-name "CLOS")
(:mop-direct clos:standard-generic-function :precedance
 (clos:generic-function clos:metaobject clos:funcallable-standard-object common-lisp:function common-lisp:standard-object common-lisp:t))
(:mop-direct clos:standard-generic-function :classof clos:funcallable-standard-class)
(:mop-direct clos:standard-generic-function :typeof clos:funcallable-standard-class)
(:mop-direct clos:standard-generic-function :superclass clos:generic-function)
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$signature) (:ordinal 1) (:type (common-lisp:simple-vector 6)) (:readers (clos::std-gf-signature))
  (:writers ((common-lisp:setf clos::std-gf-signature)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$argorder) (:ordinal 2) (:type common-lisp:list) (:readers (clos::std-gf-argorder))
  (:writers ((common-lisp:setf clos::std-gf-argorder)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$methods) (:ordinal 3) (:type common-lisp:list) (:readers (clos::std-gf-methods))
  (:writers ((common-lisp:setf clos::std-gf-methods)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$method-combination) (:ordinal 4) (:type clos:method-combination) (:readers (clos::std-gf-method-combination))
  (:writers ((common-lisp:setf clos::std-gf-method-combination)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$default-method-class) (:ordinal 5) (:type clos:class) (:readers (clos::std-gf-default-method-class))
  (:writers ((common-lisp:setf clos::std-gf-default-method-class)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$lambda-list) (:ordinal 6) (:type common-lisp:list) (:readers (clos::std-gf-lambda-list))
  (:writers ((common-lisp:setf clos::std-gf-lambda-list)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$documentation) (:ordinal 7) (:type (common-lisp:or common-lisp:null common-lisp:string)) (:readers (clos::std-gf-documentation))
  (:writers ((common-lisp:setf clos::std-gf-documentation)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$declspecs) (:ordinal 8) (:type common-lisp:list) (:readers (clos::std-gf-declspecs))
  (:writers ((common-lisp:setf clos::std-gf-declspecs)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$effective-method-cache) (:ordinal 9) (:type common-lisp:list) (:readers (clos::std-gf-effective-method-cache))
  (:writers ((common-lisp:setf clos::std-gf-effective-method-cache)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$initialized) (:ordinal 10) (:type common-lisp:boolean) (:readers (clos::std-gf-initialized))
  (:writers ((common-lisp:setf clos::std-gf-initialized)))))
(:mop-direct closer-mop:standard-generic-function :superclass clos:standard-generic-function)
(:mop-direct closer-mop:standard-generic-function :package-name "CLOSER-MOP")
(:mop-direct closer-mop:standard-generic-function :precedance
 (clos:standard-generic-function clos:generic-function clos:metaobject clos:funcallable-standard-object common-lisp:function
  common-lisp:standard-object common-lisp:t))
(:mop-direct closer-mop:standard-generic-function :classof clos:funcallable-standard-class)
(:mop-direct closer-mop:standard-generic-function :typeof clos:funcallable-standard-class)
(:mop-direct closer-mop:standard-generic-function :superclass clos:standard-generic-function)
(:mop-direct closer-mop:standard-generic-function :slot ((:name closer-mop::initial-methods) (:ordinal 1) (:initform 'common-lisp:nil)))
(:mop-direct closer-mop:standard-generic-function :prototype #<closer-mop:standard-generic-function #<unbound>>)
(:mop-direct clos:standard-generic-function :prototype #<clos:standard-generic-function #<unbound>>)
(:mop-direct clos:generic-function :prototype #<clos:generic-function #<unbound>>)
(:mop-direct clos:funcallable-standard-object :prototype #<clos:funcallable-standard-object #<unbound>>)
(:mop-direct clos:standard-stablehash :superclass common-lisp:standard-object)
(:mop-direct clos:method :superclass clos:standard-stablehash)
(:mop-direct clos::super-class :superclass clos:standard-stablehash)
(:mop-direct clos:specializer :superclass clos:standard-stablehash)
(:mop-direct clos:standard-stablehash :package-name "CLOS")
(:mop-direct clos:standard-stablehash :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct clos:standard-stablehash :classof clos:standard-class)
(:mop-direct clos:standard-stablehash :typeof clos:standard-class)
(:mop-direct clos:standard-stablehash :superclass common-lisp:standard-object)
(:mop-direct clos:standard-stablehash :slot ((:name clos::$hashcode) (:ordinal 1) (:initform (system::random-posfixnum))))
(:mop-direct clos:method :superclass clos:standard-stablehash)
(:mop-direct clos:method :superclass clos:metaobject)
(:mop-direct clos:standard-method :superclass clos:method)
(:mop-direct clos:method :package-name "CLOS")
(:mop-direct clos:method :precedance (clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:method :classof clos:standard-class)
(:mop-direct clos:method :typeof clos:standard-class)
(:mop-direct clos:method :superclass clos:standard-stablehash)
(:mop-direct clos:method :slot
 ((:name clos::$from-defgeneric) (:ordinal 1) (:type common-lisp:boolean) (:readers (clos::method-from-defgeneric))
  (:writers ((common-lisp:setf clos::method-from-defgeneric)))))
(:mop-direct clos:standard-method :superclass clos:method)
(:mop-direct clos:standard-accessor-method :superclass clos:standard-method)
(:mop-direct clos:standard-method :package-name "CLOS")
(:mop-direct clos:standard-method :precedance (clos:method clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:standard-method :classof clos:standard-class)
(:mop-direct clos:standard-method :typeof clos:standard-class)
(:mop-direct clos:standard-method :superclass clos:method)
(:mop-direct clos:standard-method :slot
 ((:name clos::$fast-function) (:ordinal 1) (:type (common-lisp:or common-lisp:null common-lisp:function))
  (:readers (clos::std-method-fast-function)) (:writers ((common-lisp:setf clos::std-method-fast-function)))))
(:mop-direct clos:standard-method :slot
 ((:name clos::$wants-next-method-p) (:ordinal 2) (:type common-lisp:boolean) (:readers (clos::std-method-wants-next-method-p))
  (:writers ((common-lisp:setf clos::std-method-wants-next-method-p)))))
(:mop-direct clos:standard-method :slot
 ((:name clos::$function) (:ordinal 3) (:type (common-lisp:or common-lisp:null common-lisp:function)) (:readers (clos::std-method-function))
  (:writers ((common-lisp:setf clos::std-method-function)))))
(:mop-direct clos:standard-method :slot
 ((:name clos::$specializers) (:ordinal 4) (:type common-lisp:list) (:readers (clos::std-method-specializers))
  (:writers ((common-lisp:setf clos::std-method-specializers)))))
(:mop-direct clos:standard-method :slot
 ((:name clos::$qualifiers) (:ordinal 5) (:type common-lisp:list) (:readers (clos::std-method-qualifiers))
  (:writers ((common-lisp:setf clos::std-method-qualifiers)))))
(:mop-direct clos:standard-method :slot
 ((:name clos::$lambda-list) (:ordinal 6) (:type common-lisp:list) (:readers (clos::std-method-lambda-list))
  (:writers ((common-lisp:setf clos::std-method-lambda-list)))))
(:mop-direct clos:standard-method :slot
 ((:name clos::$signature) (:ordinal 7) (:type (common-lisp:simple-vector 6)) (:readers (clos::std-method-signature))
  (:writers ((common-lisp:setf clos::std-method-signature)))))
(:mop-direct clos:standard-method :slot
 ((:name clos::$documentation) (:ordinal 8) (:type (common-lisp:or common-lisp:string common-lisp:null))
  (:readers (clos::std-method-documentation)) (:writers ((common-lisp:setf clos::std-method-documentation)))))
(:mop-direct clos:standard-method :slot
 ((:name clos::$gf) (:ordinal 9) (:type (common-lisp:or common-lisp:null clos:generic-function)) (:readers (clos::std-method-generic-function))
  (:writers ((common-lisp:setf clos::std-method-generic-function)))))
(:mop-direct clos:standard-accessor-method :superclass clos:standard-method)
(:mop-direct clos:standard-writer-method :superclass clos:standard-accessor-method)
(:mop-direct clos:standard-reader-method :superclass clos:standard-accessor-method)
(:mop-direct clos:standard-accessor-method :package-name "CLOS")
(:mop-direct clos:standard-accessor-method :precedance
 (clos:standard-method clos:method clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:standard-accessor-method :classof clos:standard-class)
(:mop-direct clos:standard-accessor-method :typeof clos:standard-class)
(:mop-direct clos:standard-accessor-method :superclass clos:standard-method)
(:mop-direct clos:standard-accessor-method :slot
 ((:name clos::$slot-definition) (:ordinal 1) (:type clos:direct-slot-definition) (:readers (clos::%accessor-method-slot-definition))
  (:writers ((common-lisp:setf clos::%accessor-method-slot-definition)))))
(:mop-direct clos:standard-writer-method :superclass clos:standard-accessor-method)
(:mop-direct clos:standard-writer-method :package-name "CLOS")
(:mop-direct clos:standard-writer-method :precedance
 (clos:standard-accessor-method clos:standard-method clos:method clos:standard-stablehash clos:metaobject common-lisp:standard-object
  common-lisp:t))
(:mop-direct clos:standard-writer-method :classof clos:standard-class)
(:mop-direct clos:standard-writer-method :typeof clos:standard-class)
(:mop-direct clos:standard-writer-method :superclass clos:standard-accessor-method)
(:mop-direct clos:standard-writer-method :prototype #<clos:standard-writer-method :uninitialized>)
(:mop-direct clos:standard-reader-method :superclass clos:standard-accessor-method)
(:mop-direct clos:standard-reader-method :package-name "CLOS")
(:mop-direct clos:standard-reader-method :precedance
 (clos:standard-accessor-method clos:standard-method clos:method clos:standard-stablehash clos:metaobject common-lisp:standard-object
  common-lisp:t))
(:mop-direct clos:standard-reader-method :classof clos:standard-class)
(:mop-direct clos:standard-reader-method :typeof clos:standard-class)
(:mop-direct clos:standard-reader-method :superclass clos:standard-accessor-method)
(:mop-direct clos:standard-reader-method :prototype #<clos:standard-reader-method :uninitialized>)
(:mop-direct clos:standard-accessor-method :prototype #<clos:standard-accessor-method :uninitialized>)
(:mop-direct clos:standard-method :prototype #<clos:standard-method :uninitialized>)
(:mop-direct clos:method :prototype #<clos:method #x000335A894A0>)
(:mop-direct clos::super-class :superclass clos:standard-stablehash)
(:mop-direct clos::super-class :superclass clos:metaobject)
(:mop-direct clos:forward-referenced-class :superclass clos::super-class)
(:mop-direct clos::potential-class :superclass clos::super-class)
(:mop-direct clos::super-class :package-name "CLOS")
(:mop-direct clos::super-class :precedance (clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos::super-class :classof clos:standard-class)
(:mop-direct clos::super-class :typeof clos:standard-class)
(:mop-direct clos::super-class :superclass clos:standard-stablehash)
(:mop-direct clos::super-class :slot ((:name clos::$classname) (:ordinal 1) (:type common-lisp:symbol) (:initargs (:name))))
(:mop-direct clos::super-class :slot
 ((:name clos::$direct-subclasses) (:ordinal 2) (:type (common-lisp:or common-lisp:hash-table clos::weak-list common-lisp:null))))
(:mop-direct clos:forward-referenced-class :superclass clos::super-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos:forward-referenced-class)
(:mop-direct clos:forward-referenced-class :package-name "CLOS")
(:mop-direct clos:forward-referenced-class :precedance
 (clos::super-class clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:forward-referenced-class :classof clos:standard-class)
(:mop-direct clos:forward-referenced-class :typeof clos:standard-class)
(:mop-direct clos:forward-referenced-class :superclass clos::super-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos:forward-referenced-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos::potential-class)
(:mop-direct clos::misdesigned-forward-referenced-class :package-name "CLOS")
(:mop-direct clos::misdesigned-forward-referenced-class :precedance
 (clos:forward-referenced-class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos::misdesigned-forward-referenced-class :classof clos:standard-class)
(:mop-direct clos::misdesigned-forward-referenced-class :typeof clos:standard-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos:forward-referenced-class)


(:mop-direct clos::potential-class :superclass clos:specializer)
(:mop-direct clos::potential-class :superclass clos::super-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos::potential-class)
(:mop-direct clos:class :superclass clos::potential-class)
(:mop-direct clos::potential-class :package-name "CLOS")
(:mop-direct clos::potential-class :precedance
 (clos:specializer clos::super-class clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos::potential-class :classof clos:standard-class)
(:mop-direct clos::potential-class :typeof clos:standard-class)
(:mop-direct clos::potential-class :superclass clos::super-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos:forward-referenced-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos::potential-class)
(:mop-direct clos::misdesigned-forward-referenced-class :package-name "CLOS")
(:mop-direct clos::misdesigned-forward-referenced-class :precedance
 (clos:forward-referenced-class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos::misdesigned-forward-referenced-class :classof clos:standard-class)
(:mop-direct clos::misdesigned-forward-referenced-class :typeof clos:standard-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos::potential-class)

(:mop-direct clos:class :superclass clos::potential-class)
(:mop-direct clos::slotted-class :superclass clos:class)
(:mop-direct clos:built-in-class :superclass clos:class)
(:mop-direct clos:class :package-name "CLOS")
(:mop-direct clos:class :precedance
 (clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:class :classof clos:standard-class)
(:mop-direct clos:class :typeof clos:standard-class)
(:mop-direct clos:class :superclass clos::potential-class)
(:mop-direct clos:class :slot ((:name clos::$direct-superclasses) (:ordinal 1) (:type common-lisp:list) (:initargs (:direct-superclasses))))
(:mop-direct clos:class :slot ((:name clos::$all-superclasses) (:ordinal 2) (:type common-lisp:hash-table)))
(:mop-direct clos:class :slot ((:name clos::$precedence-list) (:ordinal 3) (:type common-lisp:list)))
(:mop-direct clos:class :slot ((:name clos::$direct-slots) (:ordinal 4) (:type common-lisp:list) (:initargs (:direct-slots))))
(:mop-direct clos:class :slot ((:name clos::$slots) (:ordinal 5) (:type common-lisp:list)))
(:mop-direct clos:class :slot ((:name clos::$slot-location-table) (:ordinal 6) (:initform clos::empty-ht) (:type common-lisp:hash-table)))
(:mop-direct clos:class :slot
 ((:name clos::$direct-default-initargs) (:ordinal 7) (:type common-lisp:list) (:initargs (:direct-default-initargs))))
(:mop-direct clos:class :slot ((:name clos::$default-initargs) (:ordinal 8)))
(:mop-direct clos:class :slot
 ((:name clos::$documentation) (:ordinal 9) (:type (common-lisp:or common-lisp:string common-lisp:null)) (:initargs (:documentation))))
(:mop-direct clos:class :slot ((:name clos::$listeners) (:ordinal 10) (:type common-lisp:list)))
(:mop-direct clos:class :slot ((:name clos::$initialized) (:ordinal 11) (:initform 0) (:type (common-lisp:integer 0 6))))
(:mop-direct clos::slotted-class :superclass clos:class)
(:mop-direct clos:structure-class :superclass clos::slotted-class)
(:mop-direct clos::semi-standard-class :superclass clos::slotted-class)
(:mop-direct clos::slotted-class :package-name "CLOS")
(:mop-direct clos::slotted-class :precedance
 (clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject common-lisp:standard-object
  common-lisp:t))
(:mop-direct clos::slotted-class :classof clos:standard-class)
(:mop-direct clos::slotted-class :typeof clos:standard-class)
(:mop-direct clos::slotted-class :superclass clos:class)
(:mop-direct clos::slotted-class :slot ((:name clos::$subclass-of-stablehash-p) (:ordinal 1) (:type common-lisp:boolean)))
(:mop-direct clos::slotted-class :slot ((:name clos::$generic-accessors) (:ordinal 2) (:initform common-lisp:t)))
(:mop-direct clos::slotted-class :slot ((:name clos::$direct-accessors) (:ordinal 3) (:initform 'common-lisp:nil) (:type common-lisp:list)))
(:mop-direct clos::slotted-class :slot ((:name clos::$valid-initargs-from-slots) (:ordinal 4) (:type common-lisp:list)))
(:mop-direct clos::slotted-class :slot ((:name clos::$instance-size) (:ordinal 5) (:type (common-lisp:integer 1 common-lisp:*))))
(:mop-direct clos:structure-class :superclass clos::slotted-class)
(:mop-direct clos:structure-class :package-name "CLOS")
(:mop-direct clos:structure-class :precedance
 (clos::slotted-class clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos:structure-class :classof clos:standard-class)
(:mop-direct clos:structure-class :typeof clos:standard-class)
(:mop-direct clos:structure-class :superclass clos::slotted-class)
(:mop-direct clos:structure-class :slot ((:name clos::$names) (:ordinal 1) (:type common-lisp:cons)))
(:mop-direct clos:structure-class :slot ((:name clos::$kconstructor) (:ordinal 2) (:type common-lisp:symbol)))
(:mop-direct clos:structure-class :slot ((:name clos::$boa-constructors) (:ordinal 3) (:type common-lisp:list)))
(:mop-direct clos:structure-class :slot ((:name clos::$copier) (:ordinal 4) (:type common-lisp:symbol)))
(:mop-direct clos:structure-class :slot ((:name clos::$predicate) (:ordinal 5) (:type common-lisp:symbol)))
(:mop-direct clos:structure-class :slot
 ((:name clos::$prototype) (:ordinal 6) (:type (common-lisp:or common-lisp:structure-object common-lisp:null))))
(:mop-direct clos:structure-class :prototype #<clos:structure-class #<unbound>>)
(:mop-direct clos::semi-standard-class :superclass clos::slotted-class)
(:mop-direct clos:funcallable-standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:standard-class :superclass clos::semi-standard-class)
(:mop-direct clos::semi-standard-class :default-initargs
 ((:fixed-slot-locations common-lisp:nil #<compiled-function clos::constant-initfunction>)))
(:mop-direct clos::semi-standard-class :package-name "CLOS")
(:mop-direct clos::semi-standard-class :precedance
 (clos::slotted-class clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos::semi-standard-class :classof clos:standard-class)
(:mop-direct clos::semi-standard-class :typeof clos:standard-class)
(:mop-direct clos::semi-standard-class :superclass clos::slotted-class)
(:mop-direct clos::semi-standard-class :slot ((:name clos::$current-version) (:ordinal 1) (:type common-lisp:simple-vector)))
(:mop-direct clos::semi-standard-class :slot ((:name clos::$funcallablep) (:ordinal 2) (:type common-lisp:boolean)))
(:mop-direct clos::semi-standard-class :slot ((:name clos::$fixed-slot-locations) (:ordinal 3) (:initargs (:fixed-slot-locations))))
(:mop-direct clos::semi-standard-class :slot ((:name clos::$instantiated) (:ordinal 4) (:type common-lisp:boolean)))
(:mop-direct clos::semi-standard-class :slot
 ((:name clos::$direct-instance-specializers) (:ordinal 5) (:type (common-lisp:or common-lisp:hash-table clos::weak-list common-lisp:null))))
(:mop-direct clos::semi-standard-class :slot
 ((:name clos::$finalized-direct-subclasses) (:ordinal 6) (:initform 'common-lisp:nil)
  (:type (common-lisp:or common-lisp:hash-table clos::weak-list common-lisp:null))))
(:mop-direct clos::semi-standard-class :slot
 ((:name clos::$prototype) (:ordinal 7) (:type (common-lisp:or common-lisp:standard-object common-lisp:null))))
(:mop-direct clos:funcallable-standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:funcallable-standard-class :default-initargs
 ((:fixed-slot-locations common-lisp:nil #<compiled-function clos::constant-initfunction>)))
(:mop-direct clos:funcallable-standard-class :package-name "CLOS")
(:mop-direct clos:funcallable-standard-class :precedance
 (clos::semi-standard-class clos::slotted-class clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash
  clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:funcallable-standard-class :classof clos:standard-class)
(:mop-direct clos:funcallable-standard-class :typeof clos:standard-class)
(:mop-direct clos:funcallable-standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:funcallable-standard-class :prototype #<clos:funcallable-standard-class #<unbound> :uninitialized>)
(:mop-direct clos:standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:standard-class :default-initargs ((:fixed-slot-locations common-lisp:nil #<compiled-function clos::constant-initfunction>)))
(:mop-direct clos:standard-class :package-name "CLOS")
(:mop-direct clos:standard-class :precedance
 (clos::semi-standard-class clos::slotted-class clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash
  clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:standard-class :prototype #<clos:standard-class #<unbound> :uninitialized>)
(:mop-direct clos::semi-standard-class :prototype #<clos::semi-standard-class #<unbound> :uninitialized>)
(:mop-direct clos::slotted-class :prototype #<clos::slotted-class #<unbound>>)
(:mop-direct clos:built-in-class :superclass clos:class)
(:mop-direct clos:built-in-class :package-name "CLOS")
(:mop-direct clos:built-in-class :precedance
 (clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject common-lisp:standard-object
  common-lisp:t))
(:mop-direct clos:built-in-class :classof clos:standard-class)
(:mop-direct clos:built-in-class :typeof clos:standard-class)
(:mop-direct clos:built-in-class :superclass clos:class)
(:mop-direct clos:built-in-class :slot ((:name clos::$prototype) (:ordinal 1)))
(:mop-direct clos:built-in-class :prototype #<clos:built-in-class #<unbound>>)
(:mop-direct clos:class :prototype #<clos:class #<unbound>>)
(:mop-direct clos::potential-class :prototype #<clos::potential-class #<unbound>>)
(:mop-direct clos::super-class :prototype #<clos::super-class #x000335970228>)
(:mop-direct clos:specializer :superclass clos:standard-stablehash)
(:mop-direct clos:specializer :superclass clos:metaobject)
(:mop-direct clos:eql-specializer :superclass clos:specializer)
(:mop-direct clos::potential-class :superclass clos:specializer)
(:mop-direct clos:specializer :package-name "CLOS")
(:mop-direct clos:specializer :precedance (clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:specializer :classof clos:standard-class)
(:mop-direct clos:specializer :typeof clos:standard-class)
(:mop-direct clos:specializer :superclass clos:standard-stablehash)
(:mop-direct clos:specializer :slot ((:name clos::$direct-methods) (:ordinal 1)))
(:mop-direct clos:eql-specializer :superclass clos:specializer)
(:mop-direct clos:eql-specializer :package-name "CLOS")
(:mop-direct clos:eql-specializer :precedance
 (clos:specializer clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:eql-specializer :classof clos:standard-class)
(:mop-direct clos:eql-specializer :typeof clos:standard-class)
(:mop-direct clos:eql-specializer :superclass clos:specializer)
(:mop-direct clos:eql-specializer :slot ((:name clos::$singleton) (:ordinal 1) (:initargs (clos::singleton))))
(:mop-direct clos:eql-specializer :prototype #<clos:eql-specializer #<unbound>>)
(:mop-direct clos::potential-class :superclass clos:specializer)
(:mop-direct clos::potential-class :superclass clos::super-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos::potential-class)
(:mop-direct clos:class :superclass clos::potential-class)
(:mop-direct clos::potential-class :package-name "CLOS")
(:mop-direct clos::potential-class :precedance
 (clos:specializer clos::super-class clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos::potential-class :classof clos:standard-class)
(:mop-direct clos::potential-class :typeof clos:standard-class)
(:mop-direct clos::potential-class :superclass clos:specializer)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos:forward-referenced-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos::potential-class)
(:mop-direct clos::misdesigned-forward-referenced-class :package-name "CLOS")
(:mop-direct clos::misdesigned-forward-referenced-class :precedance
 (clos:forward-referenced-class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos::misdesigned-forward-referenced-class :classof clos:standard-class)
(:mop-direct clos::misdesigned-forward-referenced-class :typeof clos:standard-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos::potential-class)

(:mop-direct clos:class :superclass clos::potential-class)
(:mop-direct clos::slotted-class :superclass clos:class)
(:mop-direct clos:built-in-class :superclass clos:class)
(:mop-direct clos:class :package-name "CLOS")
(:mop-direct clos:class :precedance
 (clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:class :classof clos:standard-class)
(:mop-direct clos:class :typeof clos:standard-class)
(:mop-direct clos:class :superclass clos::potential-class)
(:mop-direct clos:class :slot ((:name clos::$direct-superclasses) (:ordinal 1) (:type common-lisp:list) (:initargs (:direct-superclasses))))
(:mop-direct clos:class :slot ((:name clos::$all-superclasses) (:ordinal 2) (:type common-lisp:hash-table)))
(:mop-direct clos:class :slot ((:name clos::$precedence-list) (:ordinal 3) (:type common-lisp:list)))
(:mop-direct clos:class :slot ((:name clos::$direct-slots) (:ordinal 4) (:type common-lisp:list) (:initargs (:direct-slots))))
(:mop-direct clos:class :slot ((:name clos::$slots) (:ordinal 5) (:type common-lisp:list)))
(:mop-direct clos:class :slot ((:name clos::$slot-location-table) (:ordinal 6) (:initform clos::empty-ht) (:type common-lisp:hash-table)))
(:mop-direct clos:class :slot
 ((:name clos::$direct-default-initargs) (:ordinal 7) (:type common-lisp:list) (:initargs (:direct-default-initargs))))
(:mop-direct clos:class :slot ((:name clos::$default-initargs) (:ordinal 8)))
(:mop-direct clos:class :slot
 ((:name clos::$documentation) (:ordinal 9) (:type (common-lisp:or common-lisp:string common-lisp:null)) (:initargs (:documentation))))
(:mop-direct clos:class :slot ((:name clos::$listeners) (:ordinal 10) (:type common-lisp:list)))
(:mop-direct clos:class :slot ((:name clos::$initialized) (:ordinal 11) (:initform 0) (:type (common-lisp:integer 0 6))))
(:mop-direct clos::slotted-class :superclass clos:class)
(:mop-direct clos:structure-class :superclass clos::slotted-class)
(:mop-direct clos::semi-standard-class :superclass clos::slotted-class)
(:mop-direct clos::slotted-class :package-name "CLOS")
(:mop-direct clos::slotted-class :precedance
 (clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject common-lisp:standard-object
  common-lisp:t))
(:mop-direct clos::slotted-class :classof clos:standard-class)
(:mop-direct clos::slotted-class :typeof clos:standard-class)
(:mop-direct clos::slotted-class :superclass clos:class)
(:mop-direct clos::slotted-class :slot ((:name clos::$subclass-of-stablehash-p) (:ordinal 1) (:type common-lisp:boolean)))
(:mop-direct clos::slotted-class :slot ((:name clos::$generic-accessors) (:ordinal 2) (:initform common-lisp:t)))
(:mop-direct clos::slotted-class :slot ((:name clos::$direct-accessors) (:ordinal 3) (:initform 'common-lisp:nil) (:type common-lisp:list)))
(:mop-direct clos::slotted-class :slot ((:name clos::$valid-initargs-from-slots) (:ordinal 4) (:type common-lisp:list)))
(:mop-direct clos::slotted-class :slot ((:name clos::$instance-size) (:ordinal 5) (:type (common-lisp:integer 1 common-lisp:*))))
(:mop-direct clos:structure-class :superclass clos::slotted-class)
(:mop-direct clos:structure-class :package-name "CLOS")
(:mop-direct clos:structure-class :precedance
 (clos::slotted-class clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos:structure-class :classof clos:standard-class)
(:mop-direct clos:structure-class :typeof clos:standard-class)
(:mop-direct clos:structure-class :superclass clos::slotted-class)
(:mop-direct clos:structure-class :slot ((:name clos::$names) (:ordinal 1) (:type common-lisp:cons)))
(:mop-direct clos:structure-class :slot ((:name clos::$kconstructor) (:ordinal 2) (:type common-lisp:symbol)))
(:mop-direct clos:structure-class :slot ((:name clos::$boa-constructors) (:ordinal 3) (:type common-lisp:list)))
(:mop-direct clos:structure-class :slot ((:name clos::$copier) (:ordinal 4) (:type common-lisp:symbol)))
(:mop-direct clos:structure-class :slot ((:name clos::$predicate) (:ordinal 5) (:type common-lisp:symbol)))
(:mop-direct clos:structure-class :slot
 ((:name clos::$prototype) (:ordinal 6) (:type (common-lisp:or common-lisp:structure-object common-lisp:null))))
(:mop-direct clos:structure-class :prototype #<clos:structure-class #<unbound>>)
(:mop-direct clos::semi-standard-class :superclass clos::slotted-class)
(:mop-direct clos:funcallable-standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:standard-class :superclass clos::semi-standard-class)
(:mop-direct clos::semi-standard-class :default-initargs
 ((:fixed-slot-locations common-lisp:nil #<compiled-function clos::constant-initfunction>)))
(:mop-direct clos::semi-standard-class :package-name "CLOS")
(:mop-direct clos::semi-standard-class :precedance
 (clos::slotted-class clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos::semi-standard-class :classof clos:standard-class)
(:mop-direct clos::semi-standard-class :typeof clos:standard-class)
(:mop-direct clos::semi-standard-class :superclass clos::slotted-class)
(:mop-direct clos::semi-standard-class :slot ((:name clos::$current-version) (:ordinal 1) (:type common-lisp:simple-vector)))
(:mop-direct clos::semi-standard-class :slot ((:name clos::$funcallablep) (:ordinal 2) (:type common-lisp:boolean)))
(:mop-direct clos::semi-standard-class :slot ((:name clos::$fixed-slot-locations) (:ordinal 3) (:initargs (:fixed-slot-locations))))
(:mop-direct clos::semi-standard-class :slot ((:name clos::$instantiated) (:ordinal 4) (:type common-lisp:boolean)))
(:mop-direct clos::semi-standard-class :slot
 ((:name clos::$direct-instance-specializers) (:ordinal 5) (:type (common-lisp:or common-lisp:hash-table clos::weak-list common-lisp:null))))
(:mop-direct clos::semi-standard-class :slot
 ((:name clos::$finalized-direct-subclasses) (:ordinal 6) (:initform 'common-lisp:nil)
  (:type (common-lisp:or common-lisp:hash-table clos::weak-list common-lisp:null))))
(:mop-direct clos::semi-standard-class :slot
 ((:name clos::$prototype) (:ordinal 7) (:type (common-lisp:or common-lisp:standard-object common-lisp:null))))
(:mop-direct clos:funcallable-standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:funcallable-standard-class :default-initargs
 ((:fixed-slot-locations common-lisp:nil #<compiled-function clos::constant-initfunction>)))
(:mop-direct clos:funcallable-standard-class :package-name "CLOS")
(:mop-direct clos:funcallable-standard-class :precedance
 (clos::semi-standard-class clos::slotted-class clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash
  clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:funcallable-standard-class :classof clos:standard-class)
(:mop-direct clos:funcallable-standard-class :typeof clos:standard-class)
(:mop-direct clos:funcallable-standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:funcallable-standard-class :prototype #<clos:funcallable-standard-class #<unbound> :uninitialized>)
(:mop-direct clos:standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:standard-class :default-initargs ((:fixed-slot-locations common-lisp:nil #<compiled-function clos::constant-initfunction>)))
(:mop-direct clos:standard-class :package-name "CLOS")
(:mop-direct clos:standard-class :precedance
 (clos::semi-standard-class clos::slotted-class clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash
  clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:standard-class :prototype #<clos:standard-class #<unbound> :uninitialized>)
(:mop-direct clos::semi-standard-class :prototype #<clos::semi-standard-class #<unbound> :uninitialized>)
(:mop-direct clos::slotted-class :prototype #<clos::slotted-class #<unbound>>)
(:mop-direct clos:built-in-class :superclass clos:class)
(:mop-direct clos:built-in-class :package-name "CLOS")
(:mop-direct clos:built-in-class :precedance
 (clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject common-lisp:standard-object
  common-lisp:t))
(:mop-direct clos:built-in-class :classof clos:standard-class)
(:mop-direct clos:built-in-class :typeof clos:standard-class)
(:mop-direct clos:built-in-class :superclass clos:class)
(:mop-direct clos:built-in-class :slot ((:name clos::$prototype) (:ordinal 1)))
(:mop-direct clos:built-in-class :prototype #<clos:built-in-class #<unbound>>)
(:mop-direct clos:class :prototype #<clos:class #<unbound>>)
(:mop-direct clos::potential-class :prototype #<clos::potential-class #<unbound>>)
(:mop-direct clos:specializer :prototype #<clos:specializer #x0003359FE808>)
(:mop-direct clos:standard-stablehash :prototype #<clos:standard-stablehash #x000335A01140>)
(:mop-direct clos:metaobject :superclass common-lisp:standard-object)
(:mop-direct clos:generic-function :superclass clos:metaobject)
(:mop-direct clos:method-combination :superclass clos:metaobject)
(:mop-direct clos:method :superclass clos:metaobject)
(:mop-direct clos:slot-definition :superclass clos:metaobject)
(:mop-direct clos::super-class :superclass clos:metaobject)
(:mop-direct clos:specializer :superclass clos:metaobject)
(:mop-direct clos:metaobject :package-name "CLOS")
(:mop-direct clos:metaobject :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct clos:metaobject :classof clos:standard-class)
(:mop-direct clos:metaobject :typeof clos:standard-class)
(:mop-direct clos:metaobject :superclass common-lisp:standard-object)
(:mop-direct clos:generic-function :superclass clos:metaobject)
(:mop-direct clos:generic-function :superclass clos:funcallable-standard-object)
(:mop-direct clos:standard-generic-function :superclass clos:generic-function)
(:mop-direct clos:generic-function :package-name "CLOS")
(:mop-direct clos:generic-function :precedance
 (clos:metaobject clos:funcallable-standard-object common-lisp:function common-lisp:standard-object common-lisp:t))
(:mop-direct clos:generic-function :classof clos:funcallable-standard-class)
(:mop-direct clos:generic-function :typeof clos:funcallable-standard-class)
(:mop-direct clos:generic-function :superclass clos:metaobject)
(:mop-direct clos:generic-function :slot
 ((:name clos::$listeners) (:ordinal 1) (:type common-lisp:list) (:readers (clos::gf-listeners))
  (:writers ((common-lisp:setf clos::gf-listeners)))))
(:mop-direct clos:standard-generic-function :superclass clos:generic-function)
(:mop-direct closer-mop:standard-generic-function :superclass clos:standard-generic-function)
(:mop-direct clos:standard-generic-function :package-name "CLOS")
(:mop-direct clos:standard-generic-function :precedance
 (clos:generic-function clos:metaobject clos:funcallable-standard-object common-lisp:function common-lisp:standard-object common-lisp:t))
(:mop-direct clos:standard-generic-function :classof clos:funcallable-standard-class)
(:mop-direct clos:standard-generic-function :typeof clos:funcallable-standard-class)
(:mop-direct clos:standard-generic-function :superclass clos:generic-function)
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$signature) (:ordinal 1) (:type (common-lisp:simple-vector 6)) (:readers (clos::std-gf-signature))
  (:writers ((common-lisp:setf clos::std-gf-signature)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$argorder) (:ordinal 2) (:type common-lisp:list) (:readers (clos::std-gf-argorder))
  (:writers ((common-lisp:setf clos::std-gf-argorder)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$methods) (:ordinal 3) (:type common-lisp:list) (:readers (clos::std-gf-methods))
  (:writers ((common-lisp:setf clos::std-gf-methods)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$method-combination) (:ordinal 4) (:type clos:method-combination) (:readers (clos::std-gf-method-combination))
  (:writers ((common-lisp:setf clos::std-gf-method-combination)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$default-method-class) (:ordinal 5) (:type clos:class) (:readers (clos::std-gf-default-method-class))
  (:writers ((common-lisp:setf clos::std-gf-default-method-class)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$lambda-list) (:ordinal 6) (:type common-lisp:list) (:readers (clos::std-gf-lambda-list))
  (:writers ((common-lisp:setf clos::std-gf-lambda-list)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$documentation) (:ordinal 7) (:type (common-lisp:or common-lisp:null common-lisp:string)) (:readers (clos::std-gf-documentation))
  (:writers ((common-lisp:setf clos::std-gf-documentation)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$declspecs) (:ordinal 8) (:type common-lisp:list) (:readers (clos::std-gf-declspecs))
  (:writers ((common-lisp:setf clos::std-gf-declspecs)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$effective-method-cache) (:ordinal 9) (:type common-lisp:list) (:readers (clos::std-gf-effective-method-cache))
  (:writers ((common-lisp:setf clos::std-gf-effective-method-cache)))))
(:mop-direct clos:standard-generic-function :slot
 ((:name clos::$initialized) (:ordinal 10) (:type common-lisp:boolean) (:readers (clos::std-gf-initialized))
  (:writers ((common-lisp:setf clos::std-gf-initialized)))))
(:mop-direct closer-mop:standard-generic-function :superclass clos:standard-generic-function)
(:mop-direct closer-mop:standard-generic-function :package-name "CLOSER-MOP")
(:mop-direct closer-mop:standard-generic-function :precedance
 (clos:standard-generic-function clos:generic-function clos:metaobject clos:funcallable-standard-object common-lisp:function
  common-lisp:standard-object common-lisp:t))
(:mop-direct closer-mop:standard-generic-function :classof clos:funcallable-standard-class)
(:mop-direct closer-mop:standard-generic-function :typeof clos:funcallable-standard-class)
(:mop-direct closer-mop:standard-generic-function :superclass clos:standard-generic-function)
(:mop-direct closer-mop:standard-generic-function :slot ((:name closer-mop::initial-methods) (:ordinal 1) (:initform 'common-lisp:nil)))
(:mop-direct closer-mop:standard-generic-function :prototype #<closer-mop:standard-generic-function #<unbound>>)
(:mop-direct clos:standard-generic-function :prototype #<clos:standard-generic-function #<unbound>>)
(:mop-direct clos:generic-function :prototype #<clos:generic-function #<unbound>>)
(:mop-direct clos:method-combination :superclass clos:metaobject)
(:mop-direct clos:method-combination :package-name "CLOS")
(:mop-direct clos:method-combination :precedance (clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:method-combination :classof clos:standard-class)
(:mop-direct clos:method-combination :typeof clos:standard-class)
(:mop-direct clos:method-combination :superclass clos:metaobject)
(:mop-direct clos:method-combination :slot
 ((:name clos::name) (:ordinal 1) (:type common-lisp:symbol) (:readers (clos::method-combination-name))
  (:writers ((common-lisp:setf clos::method-combination-name)))))
(:mop-direct clos:method-combination :slot
 ((:name clos:documentation) (:ordinal 2) (:type (common-lisp:or common-lisp:null common-lisp:string))
  (:readers (clos::method-combination-documentation)) (:writers ((common-lisp:setf clos::method-combination-documentation)))))
(:mop-direct clos:method-combination :slot
 ((:name clos::check-options) (:ordinal 3) (:type common-lisp:function) (:readers (clos::method-combination-check-options))
  (:writers ((common-lisp:setf clos::method-combination-check-options)))))
(:mop-direct clos:method-combination :slot
 ((:name clos::expander) (:ordinal 4) (:type common-lisp:function) (:readers (clos::method-combination-expander))
  (:writers ((common-lisp:setf clos::method-combination-expander)))))
(:mop-direct clos:method-combination :slot
 ((:name clos::check-method-qualifiers) (:ordinal 5) (:type common-lisp:function) (:readers (clos::method-combination-check-method-qualifiers))
  (:writers ((common-lisp:setf clos::method-combination-check-method-qualifiers)))))
(:mop-direct clos:method-combination :slot
 ((:name clos::call-next-method-allowed) (:ordinal 6) (:type common-lisp:function)
  (:readers (clos::method-combination-call-next-method-allowed))
  (:writers ((common-lisp:setf clos::method-combination-call-next-method-allowed)))))
(:mop-direct clos:method-combination :slot
 ((:name clos::declarations) (:ordinal 7) (:type common-lisp:list) (:readers (clos::method-combination-declarations))
  (:writers ((common-lisp:setf clos::method-combination-declarations)))))
(:mop-direct clos:method-combination :slot
 ((:name clos::qualifiers) (:ordinal 8) (:type common-lisp:list) (:readers (clos::method-combination-qualifiers))
  (:writers ((common-lisp:setf clos::method-combination-qualifiers)))))
(:mop-direct clos:method-combination :slot
 ((:name clos::operator) (:ordinal 9) (:type common-lisp:symbol) (:readers (clos::method-combination-operator))
  (:writers ((common-lisp:setf clos::method-combination-operator)))))
(:mop-direct clos:method-combination :slot
 ((:name clos::identity-with-one-argument) (:ordinal 10) (:type common-lisp:boolean)
  (:readers (clos::method-combination-identity-with-one-argument))
  (:writers ((common-lisp:setf clos::method-combination-identity-with-one-argument)))))
(:mop-direct clos:method-combination :slot
 ((:name clos::long-expander) (:ordinal 11) (:type common-lisp:function) (:readers (clos::method-combination-long-expander))
  (:writers ((common-lisp:setf clos::method-combination-long-expander)))))
(:mop-direct clos:method-combination :slot
 ((:name clos::arguments-lambda-list) (:ordinal 12) (:type common-lisp:list) (:readers (clos::method-combination-arguments-lambda-list))
  (:writers ((common-lisp:setf clos::method-combination-arguments-lambda-list)))))
(:mop-direct clos:method-combination :slot
 ((:name clos::options) (:ordinal 13) (:type common-lisp:list) (:readers (clos::method-combination-options))
  (:writers ((common-lisp:setf clos::method-combination-options)))))
(:mop-direct clos:method-combination :prototype #<clos:method-combination #<unbound> #x000335A65A10>)
(:mop-direct clos:method :superclass clos:standard-stablehash)
(:mop-direct clos:method :superclass clos:metaobject)
(:mop-direct clos:standard-method :superclass clos:method)
(:mop-direct clos:method :package-name "CLOS")
(:mop-direct clos:method :precedance (clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:method :classof clos:standard-class)
(:mop-direct clos:method :typeof clos:standard-class)
(:mop-direct clos:method :superclass clos:metaobject)
(:mop-direct clos:method :slot
 ((:name clos::$from-defgeneric) (:ordinal 1) (:type common-lisp:boolean) (:readers (clos::method-from-defgeneric))
  (:writers ((common-lisp:setf clos::method-from-defgeneric)))))
(:mop-direct clos:standard-method :superclass clos:method)
(:mop-direct clos:standard-accessor-method :superclass clos:standard-method)
(:mop-direct clos:standard-method :package-name "CLOS")
(:mop-direct clos:standard-method :precedance (clos:method clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:standard-method :classof clos:standard-class)
(:mop-direct clos:standard-method :typeof clos:standard-class)
(:mop-direct clos:standard-method :superclass clos:method)
(:mop-direct clos:standard-method :slot
 ((:name clos::$fast-function) (:ordinal 1) (:type (common-lisp:or common-lisp:null common-lisp:function))
  (:readers (clos::std-method-fast-function)) (:writers ((common-lisp:setf clos::std-method-fast-function)))))
(:mop-direct clos:standard-method :slot
 ((:name clos::$wants-next-method-p) (:ordinal 2) (:type common-lisp:boolean) (:readers (clos::std-method-wants-next-method-p))
  (:writers ((common-lisp:setf clos::std-method-wants-next-method-p)))))
(:mop-direct clos:standard-method :slot
 ((:name clos::$function) (:ordinal 3) (:type (common-lisp:or common-lisp:null common-lisp:function)) (:readers (clos::std-method-function))
  (:writers ((common-lisp:setf clos::std-method-function)))))
(:mop-direct clos:standard-method :slot
 ((:name clos::$specializers) (:ordinal 4) (:type common-lisp:list) (:readers (clos::std-method-specializers))
  (:writers ((common-lisp:setf clos::std-method-specializers)))))
(:mop-direct clos:standard-method :slot
 ((:name clos::$qualifiers) (:ordinal 5) (:type common-lisp:list) (:readers (clos::std-method-qualifiers))
  (:writers ((common-lisp:setf clos::std-method-qualifiers)))))
(:mop-direct clos:standard-method :slot
 ((:name clos::$lambda-list) (:ordinal 6) (:type common-lisp:list) (:readers (clos::std-method-lambda-list))
  (:writers ((common-lisp:setf clos::std-method-lambda-list)))))
(:mop-direct clos:standard-method :slot
 ((:name clos::$signature) (:ordinal 7) (:type (common-lisp:simple-vector 6)) (:readers (clos::std-method-signature))
  (:writers ((common-lisp:setf clos::std-method-signature)))))
(:mop-direct clos:standard-method :slot
 ((:name clos::$documentation) (:ordinal 8) (:type (common-lisp:or common-lisp:string common-lisp:null))
  (:readers (clos::std-method-documentation)) (:writers ((common-lisp:setf clos::std-method-documentation)))))
(:mop-direct clos:standard-method :slot
 ((:name clos::$gf) (:ordinal 9) (:type (common-lisp:or common-lisp:null clos:generic-function)) (:readers (clos::std-method-generic-function))
  (:writers ((common-lisp:setf clos::std-method-generic-function)))))
(:mop-direct clos:standard-accessor-method :superclass clos:standard-method)
(:mop-direct clos:standard-writer-method :superclass clos:standard-accessor-method)
(:mop-direct clos:standard-reader-method :superclass clos:standard-accessor-method)
(:mop-direct clos:standard-accessor-method :package-name "CLOS")
(:mop-direct clos:standard-accessor-method :precedance
 (clos:standard-method clos:method clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:standard-accessor-method :classof clos:standard-class)
(:mop-direct clos:standard-accessor-method :typeof clos:standard-class)
(:mop-direct clos:standard-accessor-method :superclass clos:standard-method)
(:mop-direct clos:standard-accessor-method :slot
 ((:name clos::$slot-definition) (:ordinal 1) (:type clos:direct-slot-definition) (:readers (clos::%accessor-method-slot-definition))
  (:writers ((common-lisp:setf clos::%accessor-method-slot-definition)))))
(:mop-direct clos:standard-writer-method :superclass clos:standard-accessor-method)
(:mop-direct clos:standard-writer-method :package-name "CLOS")
(:mop-direct clos:standard-writer-method :precedance
 (clos:standard-accessor-method clos:standard-method clos:method clos:standard-stablehash clos:metaobject common-lisp:standard-object
  common-lisp:t))
(:mop-direct clos:standard-writer-method :classof clos:standard-class)
(:mop-direct clos:standard-writer-method :typeof clos:standard-class)
(:mop-direct clos:standard-writer-method :superclass clos:standard-accessor-method)
(:mop-direct clos:standard-writer-method :prototype #<clos:standard-writer-method :uninitialized>)
(:mop-direct clos:standard-reader-method :superclass clos:standard-accessor-method)
(:mop-direct clos:standard-reader-method :package-name "CLOS")
(:mop-direct clos:standard-reader-method :precedance
 (clos:standard-accessor-method clos:standard-method clos:method clos:standard-stablehash clos:metaobject common-lisp:standard-object
  common-lisp:t))
(:mop-direct clos:standard-reader-method :classof clos:standard-class)
(:mop-direct clos:standard-reader-method :typeof clos:standard-class)
(:mop-direct clos:standard-reader-method :superclass clos:standard-accessor-method)
(:mop-direct clos:standard-reader-method :prototype #<clos:standard-reader-method :uninitialized>)
(:mop-direct clos:standard-accessor-method :prototype #<clos:standard-accessor-method :uninitialized>)
(:mop-direct clos:standard-method :prototype #<clos:standard-method :uninitialized>)
(:mop-direct clos:method :prototype #<clos:method #x0003359696A8>)
(:mop-direct clos:slot-definition :superclass clos:metaobject)
(:mop-direct clos:standard-slot-definition :superclass clos:slot-definition)
(:mop-direct clos:effective-slot-definition :superclass clos:slot-definition)
(:mop-direct clos:direct-slot-definition :superclass clos:slot-definition)
(:mop-direct clos:slot-definition :package-name "CLOS")
(:mop-direct clos:slot-definition :precedance (clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:slot-definition :classof clos:standard-class)
(:mop-direct clos:slot-definition :typeof clos:standard-class)
(:mop-direct clos:slot-definition :superclass clos:metaobject)
(:mop-direct clos:slot-definition :slot ((:name clos::$name) (:ordinal 1) (:type common-lisp:symbol) (:initargs (:name))))
(:mop-direct clos:slot-definition :slot ((:name clos::$initargs) (:ordinal 2) (:type common-lisp:list) (:initargs (:initargs))))
(:mop-direct clos:slot-definition :slot ((:name clos::$type) (:ordinal 3) (:initargs (:type))))
(:mop-direct clos:slot-definition :slot ((:name clos::$allocation) (:ordinal 4) (:type common-lisp:symbol) (:initargs (:allocation))))
(:mop-direct clos:slot-definition :slot
 ((:name clos::$inheritable-initer) (:ordinal 5) (:type common-lisp:cons) (:initargs (clos::inheritable-initer))))
(:mop-direct clos:slot-definition :slot
 ((:name clos::$inheritable-doc) (:ordinal 6) (:type common-lisp:cons) (:initargs (clos::inheritable-doc))))
(:mop-direct clos:standard-slot-definition :superclass clos:slot-definition)
(:mop-direct clos:standard-effective-slot-definition :superclass clos:standard-slot-definition)
(:mop-direct clos:standard-direct-slot-definition :superclass clos:standard-slot-definition)
(:mop-direct clos:standard-slot-definition :package-name "CLOS")
(:mop-direct clos:standard-slot-definition :precedance (clos:slot-definition clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:standard-slot-definition :classof clos:standard-class)
(:mop-direct clos:standard-slot-definition :typeof clos:standard-class)
(:mop-direct clos:standard-slot-definition :superclass clos:slot-definition)
(:mop-direct clos:standard-effective-slot-definition :superclass clos:effective-slot-definition)
(:mop-direct clos:standard-effective-slot-definition :superclass clos:standard-slot-definition)
(:mop-direct clos:standard-effective-slot-definition :package-name "CLOS")
(:mop-direct clos:standard-effective-slot-definition :precedance
 (clos:effective-slot-definition clos:standard-slot-definition clos:slot-definition clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:standard-effective-slot-definition :classof clos:standard-class)
(:mop-direct clos:standard-effective-slot-definition :typeof clos:standard-class)
(:mop-direct clos:standard-effective-slot-definition :superclass clos:standard-slot-definition)
(:mop-direct clos:standard-effective-slot-definition :prototype #<clos:standard-effective-slot-definition #<unbound> #x000335AC7230>)
(:mop-direct clos:standard-direct-slot-definition :superclass clos:direct-slot-definition)
(:mop-direct clos:standard-direct-slot-definition :superclass clos:standard-slot-definition)
(:mop-direct clos:standard-direct-slot-definition :package-name "CLOS")
(:mop-direct clos:standard-direct-slot-definition :precedance
 (clos:direct-slot-definition clos:standard-slot-definition clos:slot-definition clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:standard-direct-slot-definition :classof clos:standard-class)
(:mop-direct clos:standard-direct-slot-definition :typeof clos:standard-class)
(:mop-direct clos:standard-direct-slot-definition :superclass clos:standard-slot-definition)
(:mop-direct clos:standard-direct-slot-definition :prototype #<clos:standard-direct-slot-definition #<unbound> #x000335ACF918>)
(:mop-direct clos:standard-slot-definition :prototype #<clos:standard-slot-definition #<unbound> #x000335AD28C0>)
(:mop-direct clos:effective-slot-definition :superclass clos:slot-definition)
(:mop-direct clos::structure-effective-slot-definition :superclass clos:effective-slot-definition)
(:mop-direct clos:standard-effective-slot-definition :superclass clos:effective-slot-definition)
(:mop-direct clos:effective-slot-definition :package-name "CLOS")
(:mop-direct clos:effective-slot-definition :precedance (clos:slot-definition clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:effective-slot-definition :classof clos:standard-class)
(:mop-direct clos:effective-slot-definition :typeof clos:standard-class)
(:mop-direct clos:effective-slot-definition :superclass clos:slot-definition)
(:mop-direct clos:effective-slot-definition :slot
 ((:name clos::$location) (:ordinal 1) (:type (common-lisp:or common-lisp:null common-lisp:integer common-lisp:cons))
  (:initargs (clos::location))))
(:mop-direct clos:effective-slot-definition :slot ((:name clos::$efm-svuc) (:ordinal 2) (:type common-lisp:function)))
(:mop-direct clos:effective-slot-definition :slot ((:name clos::$efm-ssvuc) (:ordinal 3) (:type common-lisp:function)))
(:mop-direct clos:effective-slot-definition :slot ((:name clos::$efm-sbuc) (:ordinal 4) (:type common-lisp:function)))
(:mop-direct clos:effective-slot-definition :slot ((:name clos::$efm-smuc) (:ordinal 5) (:type common-lisp:function)))
(:mop-direct clos::structure-effective-slot-definition :superclass clos:effective-slot-definition)
(:mop-direct clos::structure-effective-slot-definition :package-name "CLOS")
(:mop-direct clos::structure-effective-slot-definition :precedance
 (clos:effective-slot-definition clos:slot-definition clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos::structure-effective-slot-definition :classof clos:standard-class)
(:mop-direct clos::structure-effective-slot-definition :typeof clos:standard-class)
(:mop-direct clos::structure-effective-slot-definition :superclass clos:effective-slot-definition)
(:mop-direct clos::structure-effective-slot-definition :slot
 ((:name clos::$efm-svuc) (:ordinal 1) (:initform #'clos::%slot-value-using-class) (:type common-lisp:function)))
(:mop-direct clos::structure-effective-slot-definition :slot
 ((:name clos::$efm-ssvuc) (:ordinal 2) (:initform #'clos::%set-slot-value-using-class) (:type common-lisp:function)))
(:mop-direct clos::structure-effective-slot-definition :slot
 ((:name clos::$efm-sbuc) (:ordinal 3) (:initform #'clos::%slot-boundp-using-class) (:type common-lisp:function)))
(:mop-direct clos::structure-effective-slot-definition :slot
 ((:name clos::$efm-smuc) (:ordinal 4) (:initform #'clos::%slot-makunbound-using-class) (:type common-lisp:function)))
(:mop-direct clos::structure-effective-slot-definition :slot
 ((:name clos::$readonly) (:ordinal 5) (:type common-lisp:boolean) (:initargs (clos::readonly))))
(:mop-direct clos::structure-effective-slot-definition :prototype #<clos::structure-effective-slot-definition #<unbound> #x000335AF1598>)
(:mop-direct clos:standard-effective-slot-definition :superclass clos:effective-slot-definition)
(:mop-direct clos:standard-effective-slot-definition :superclass clos:standard-slot-definition)
(:mop-direct clos:standard-effective-slot-definition :package-name "CLOS")
(:mop-direct clos:standard-effective-slot-definition :precedance
 (clos:effective-slot-definition clos:standard-slot-definition clos:slot-definition clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:standard-effective-slot-definition :classof clos:standard-class)
(:mop-direct clos:standard-effective-slot-definition :typeof clos:standard-class)
(:mop-direct clos:standard-effective-slot-definition :superclass clos:effective-slot-definition)
(:mop-direct clos:standard-effective-slot-definition :prototype #<clos:standard-effective-slot-definition #<unbound> #x000335AC7230>)
(:mop-direct clos:effective-slot-definition :prototype #<clos:effective-slot-definition #<unbound> #x000335AFC908>)
(:mop-direct clos:direct-slot-definition :superclass clos:slot-definition)
(:mop-direct clos::structure-direct-slot-definition :superclass clos:direct-slot-definition)
(:mop-direct clos:standard-direct-slot-definition :superclass clos:direct-slot-definition)
(:mop-direct clos:direct-slot-definition :package-name "CLOS")
(:mop-direct clos:direct-slot-definition :precedance (clos:slot-definition clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:direct-slot-definition :classof clos:standard-class)
(:mop-direct clos:direct-slot-definition :typeof clos:standard-class)
(:mop-direct clos:direct-slot-definition :superclass clos:slot-definition)
(:mop-direct clos:direct-slot-definition :slot ((:name clos::$readers) (:ordinal 1) (:type common-lisp:list) (:initargs (:readers))))
(:mop-direct clos:direct-slot-definition :slot ((:name clos::$writers) (:ordinal 2) (:type common-lisp:list) (:initargs (:writers))))
(:mop-direct clos::structure-direct-slot-definition :superclass clos:direct-slot-definition)
(:mop-direct clos::structure-direct-slot-definition :package-name "CLOS")
(:mop-direct clos::structure-direct-slot-definition :precedance
 (clos:direct-slot-definition clos:slot-definition clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos::structure-direct-slot-definition :classof clos:standard-class)
(:mop-direct clos::structure-direct-slot-definition :typeof clos:standard-class)
(:mop-direct clos::structure-direct-slot-definition :superclass clos:direct-slot-definition)
(:mop-direct clos::structure-direct-slot-definition :prototype #<clos::structure-direct-slot-definition #<unbound> #x000335B0D180>)
(:mop-direct clos:standard-direct-slot-definition :superclass clos:direct-slot-definition)
(:mop-direct clos:standard-direct-slot-definition :superclass clos:standard-slot-definition)
(:mop-direct clos:standard-direct-slot-definition :package-name "CLOS")
(:mop-direct clos:standard-direct-slot-definition :precedance
 (clos:direct-slot-definition clos:standard-slot-definition clos:slot-definition clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:standard-direct-slot-definition :classof clos:standard-class)
(:mop-direct clos:standard-direct-slot-definition :typeof clos:standard-class)
(:mop-direct clos:standard-direct-slot-definition :superclass clos:direct-slot-definition)
(:mop-direct clos:standard-direct-slot-definition :prototype #<clos:standard-direct-slot-definition #<unbound> #x000335ACF918>)
(:mop-direct clos:direct-slot-definition :prototype #<clos:direct-slot-definition #<unbound> #x000335B184A8>)
(:mop-direct clos:slot-definition :prototype #<clos:slot-definition #<unbound> #x000335B1B4D8>)
(:mop-direct clos::super-class :superclass clos:standard-stablehash)
(:mop-direct clos::super-class :superclass clos:metaobject)
(:mop-direct clos:forward-referenced-class :superclass clos::super-class)
(:mop-direct clos::potential-class :superclass clos::super-class)
(:mop-direct clos::super-class :package-name "CLOS")
(:mop-direct clos::super-class :precedance (clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos::super-class :classof clos:standard-class)
(:mop-direct clos::super-class :typeof clos:standard-class)
(:mop-direct clos::super-class :superclass clos:metaobject)
(:mop-direct clos::super-class :slot ((:name clos::$classname) (:ordinal 1) (:type common-lisp:symbol) (:initargs (:name))))
(:mop-direct clos::super-class :slot
 ((:name clos::$direct-subclasses) (:ordinal 2) (:type (common-lisp:or common-lisp:hash-table clos::weak-list common-lisp:null))))
(:mop-direct clos:forward-referenced-class :superclass clos::super-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos:forward-referenced-class)
(:mop-direct clos:forward-referenced-class :package-name "CLOS")
(:mop-direct clos:forward-referenced-class :precedance
 (clos::super-class clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:forward-referenced-class :classof clos:standard-class)
(:mop-direct clos:forward-referenced-class :typeof clos:standard-class)
(:mop-direct clos:forward-referenced-class :superclass clos::super-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos:forward-referenced-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos::potential-class)
(:mop-direct clos::misdesigned-forward-referenced-class :package-name "CLOS")
(:mop-direct clos::misdesigned-forward-referenced-class :precedance
 (clos:forward-referenced-class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos::misdesigned-forward-referenced-class :classof clos:standard-class)
(:mop-direct clos::misdesigned-forward-referenced-class :typeof clos:standard-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos:forward-referenced-class)


(:mop-direct clos::potential-class :superclass clos:specializer)
(:mop-direct clos::potential-class :superclass clos::super-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos::potential-class)
(:mop-direct clos:class :superclass clos::potential-class)
(:mop-direct clos::potential-class :package-name "CLOS")
(:mop-direct clos::potential-class :precedance
 (clos:specializer clos::super-class clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos::potential-class :classof clos:standard-class)
(:mop-direct clos::potential-class :typeof clos:standard-class)
(:mop-direct clos::potential-class :superclass clos::super-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos:forward-referenced-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos::potential-class)
(:mop-direct clos::misdesigned-forward-referenced-class :package-name "CLOS")
(:mop-direct clos::misdesigned-forward-referenced-class :precedance
 (clos:forward-referenced-class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos::misdesigned-forward-referenced-class :classof clos:standard-class)
(:mop-direct clos::misdesigned-forward-referenced-class :typeof clos:standard-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos::potential-class)

(:mop-direct clos:class :superclass clos::potential-class)
(:mop-direct clos::slotted-class :superclass clos:class)
(:mop-direct clos:built-in-class :superclass clos:class)
(:mop-direct clos:class :package-name "CLOS")
(:mop-direct clos:class :precedance
 (clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:class :classof clos:standard-class)
(:mop-direct clos:class :typeof clos:standard-class)
(:mop-direct clos:class :superclass clos::potential-class)
(:mop-direct clos:class :slot ((:name clos::$direct-superclasses) (:ordinal 1) (:type common-lisp:list) (:initargs (:direct-superclasses))))
(:mop-direct clos:class :slot ((:name clos::$all-superclasses) (:ordinal 2) (:type common-lisp:hash-table)))
(:mop-direct clos:class :slot ((:name clos::$precedence-list) (:ordinal 3) (:type common-lisp:list)))
(:mop-direct clos:class :slot ((:name clos::$direct-slots) (:ordinal 4) (:type common-lisp:list) (:initargs (:direct-slots))))
(:mop-direct clos:class :slot ((:name clos::$slots) (:ordinal 5) (:type common-lisp:list)))
(:mop-direct clos:class :slot ((:name clos::$slot-location-table) (:ordinal 6) (:initform clos::empty-ht) (:type common-lisp:hash-table)))
(:mop-direct clos:class :slot
 ((:name clos::$direct-default-initargs) (:ordinal 7) (:type common-lisp:list) (:initargs (:direct-default-initargs))))
(:mop-direct clos:class :slot ((:name clos::$default-initargs) (:ordinal 8)))
(:mop-direct clos:class :slot
 ((:name clos::$documentation) (:ordinal 9) (:type (common-lisp:or common-lisp:string common-lisp:null)) (:initargs (:documentation))))
(:mop-direct clos:class :slot ((:name clos::$listeners) (:ordinal 10) (:type common-lisp:list)))
(:mop-direct clos:class :slot ((:name clos::$initialized) (:ordinal 11) (:initform 0) (:type (common-lisp:integer 0 6))))
(:mop-direct clos::slotted-class :superclass clos:class)
(:mop-direct clos:structure-class :superclass clos::slotted-class)
(:mop-direct clos::semi-standard-class :superclass clos::slotted-class)
(:mop-direct clos::slotted-class :package-name "CLOS")
(:mop-direct clos::slotted-class :precedance
 (clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject common-lisp:standard-object
  common-lisp:t))
(:mop-direct clos::slotted-class :classof clos:standard-class)
(:mop-direct clos::slotted-class :typeof clos:standard-class)
(:mop-direct clos::slotted-class :superclass clos:class)
(:mop-direct clos::slotted-class :slot ((:name clos::$subclass-of-stablehash-p) (:ordinal 1) (:type common-lisp:boolean)))
(:mop-direct clos::slotted-class :slot ((:name clos::$generic-accessors) (:ordinal 2) (:initform common-lisp:t)))
(:mop-direct clos::slotted-class :slot ((:name clos::$direct-accessors) (:ordinal 3) (:initform 'common-lisp:nil) (:type common-lisp:list)))
(:mop-direct clos::slotted-class :slot ((:name clos::$valid-initargs-from-slots) (:ordinal 4) (:type common-lisp:list)))
(:mop-direct clos::slotted-class :slot ((:name clos::$instance-size) (:ordinal 5) (:type (common-lisp:integer 1 common-lisp:*))))
(:mop-direct clos:structure-class :superclass clos::slotted-class)
(:mop-direct clos:structure-class :package-name "CLOS")
(:mop-direct clos:structure-class :precedance
 (clos::slotted-class clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos:structure-class :classof clos:standard-class)
(:mop-direct clos:structure-class :typeof clos:standard-class)
(:mop-direct clos:structure-class :superclass clos::slotted-class)
(:mop-direct clos:structure-class :slot ((:name clos::$names) (:ordinal 1) (:type common-lisp:cons)))
(:mop-direct clos:structure-class :slot ((:name clos::$kconstructor) (:ordinal 2) (:type common-lisp:symbol)))
(:mop-direct clos:structure-class :slot ((:name clos::$boa-constructors) (:ordinal 3) (:type common-lisp:list)))
(:mop-direct clos:structure-class :slot ((:name clos::$copier) (:ordinal 4) (:type common-lisp:symbol)))
(:mop-direct clos:structure-class :slot ((:name clos::$predicate) (:ordinal 5) (:type common-lisp:symbol)))
(:mop-direct clos:structure-class :slot
 ((:name clos::$prototype) (:ordinal 6) (:type (common-lisp:or common-lisp:structure-object common-lisp:null))))
(:mop-direct clos:structure-class :prototype #<clos:structure-class #<unbound>>)
(:mop-direct clos::semi-standard-class :superclass clos::slotted-class)
(:mop-direct clos:funcallable-standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:standard-class :superclass clos::semi-standard-class)
(:mop-direct clos::semi-standard-class :default-initargs
 ((:fixed-slot-locations common-lisp:nil #<compiled-function clos::constant-initfunction>)))
(:mop-direct clos::semi-standard-class :package-name "CLOS")
(:mop-direct clos::semi-standard-class :precedance
 (clos::slotted-class clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos::semi-standard-class :classof clos:standard-class)
(:mop-direct clos::semi-standard-class :typeof clos:standard-class)
(:mop-direct clos::semi-standard-class :superclass clos::slotted-class)
(:mop-direct clos::semi-standard-class :slot ((:name clos::$current-version) (:ordinal 1) (:type common-lisp:simple-vector)))
(:mop-direct clos::semi-standard-class :slot ((:name clos::$funcallablep) (:ordinal 2) (:type common-lisp:boolean)))
(:mop-direct clos::semi-standard-class :slot ((:name clos::$fixed-slot-locations) (:ordinal 3) (:initargs (:fixed-slot-locations))))
(:mop-direct clos::semi-standard-class :slot ((:name clos::$instantiated) (:ordinal 4) (:type common-lisp:boolean)))
(:mop-direct clos::semi-standard-class :slot
 ((:name clos::$direct-instance-specializers) (:ordinal 5) (:type (common-lisp:or common-lisp:hash-table clos::weak-list common-lisp:null))))
(:mop-direct clos::semi-standard-class :slot
 ((:name clos::$finalized-direct-subclasses) (:ordinal 6) (:initform 'common-lisp:nil)
  (:type (common-lisp:or common-lisp:hash-table clos::weak-list common-lisp:null))))
(:mop-direct clos::semi-standard-class :slot
 ((:name clos::$prototype) (:ordinal 7) (:type (common-lisp:or common-lisp:standard-object common-lisp:null))))
(:mop-direct clos:funcallable-standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:funcallable-standard-class :default-initargs
 ((:fixed-slot-locations common-lisp:nil #<compiled-function clos::constant-initfunction>)))
(:mop-direct clos:funcallable-standard-class :package-name "CLOS")
(:mop-direct clos:funcallable-standard-class :precedance
 (clos::semi-standard-class clos::slotted-class clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash
  clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:funcallable-standard-class :classof clos:standard-class)
(:mop-direct clos:funcallable-standard-class :typeof clos:standard-class)
(:mop-direct clos:funcallable-standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:funcallable-standard-class :prototype #<clos:funcallable-standard-class #<unbound> :uninitialized>)
(:mop-direct clos:standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:standard-class :default-initargs ((:fixed-slot-locations common-lisp:nil #<compiled-function clos::constant-initfunction>)))
(:mop-direct clos:standard-class :package-name "CLOS")
(:mop-direct clos:standard-class :precedance
 (clos::semi-standard-class clos::slotted-class clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash
  clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:standard-class :prototype #<clos:standard-class #<unbound> :uninitialized>)
(:mop-direct clos::semi-standard-class :prototype #<clos::semi-standard-class #<unbound> :uninitialized>)
(:mop-direct clos::slotted-class :prototype #<clos::slotted-class #<unbound>>)
(:mop-direct clos:built-in-class :superclass clos:class)
(:mop-direct clos:built-in-class :package-name "CLOS")
(:mop-direct clos:built-in-class :precedance
 (clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject common-lisp:standard-object
  common-lisp:t))
(:mop-direct clos:built-in-class :classof clos:standard-class)
(:mop-direct clos:built-in-class :typeof clos:standard-class)
(:mop-direct clos:built-in-class :superclass clos:class)
(:mop-direct clos:built-in-class :slot ((:name clos::$prototype) (:ordinal 1)))
(:mop-direct clos:built-in-class :prototype #<clos:built-in-class #<unbound>>)
(:mop-direct clos:class :prototype #<clos:class #<unbound>>)
(:mop-direct clos::potential-class :prototype #<clos::potential-class #<unbound>>)
(:mop-direct clos::super-class :prototype #<clos::super-class #x000335969BF8>)
(:mop-direct clos:specializer :superclass clos:standard-stablehash)
(:mop-direct clos:specializer :superclass clos:metaobject)
(:mop-direct clos:eql-specializer :superclass clos:specializer)
(:mop-direct clos::potential-class :superclass clos:specializer)
(:mop-direct clos:specializer :package-name "CLOS")
(:mop-direct clos:specializer :precedance (clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:specializer :classof clos:standard-class)
(:mop-direct clos:specializer :typeof clos:standard-class)
(:mop-direct clos:specializer :superclass clos:metaobject)
(:mop-direct clos:specializer :slot ((:name clos::$direct-methods) (:ordinal 1)))
(:mop-direct clos:eql-specializer :superclass clos:specializer)
(:mop-direct clos:eql-specializer :package-name "CLOS")
(:mop-direct clos:eql-specializer :precedance
 (clos:specializer clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:eql-specializer :classof clos:standard-class)
(:mop-direct clos:eql-specializer :typeof clos:standard-class)
(:mop-direct clos:eql-specializer :superclass clos:specializer)
(:mop-direct clos:eql-specializer :slot ((:name clos::$singleton) (:ordinal 1) (:initargs (clos::singleton))))
(:mop-direct clos:eql-specializer :prototype #<clos:eql-specializer #<unbound>>)
(:mop-direct clos::potential-class :superclass clos:specializer)
(:mop-direct clos::potential-class :superclass clos::super-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos::potential-class)
(:mop-direct clos:class :superclass clos::potential-class)
(:mop-direct clos::potential-class :package-name "CLOS")
(:mop-direct clos::potential-class :precedance
 (clos:specializer clos::super-class clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos::potential-class :classof clos:standard-class)
(:mop-direct clos::potential-class :typeof clos:standard-class)
(:mop-direct clos::potential-class :superclass clos:specializer)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos:forward-referenced-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos::potential-class)
(:mop-direct clos::misdesigned-forward-referenced-class :package-name "CLOS")
(:mop-direct clos::misdesigned-forward-referenced-class :precedance
 (clos:forward-referenced-class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos::misdesigned-forward-referenced-class :classof clos:standard-class)
(:mop-direct clos::misdesigned-forward-referenced-class :typeof clos:standard-class)
(:mop-direct clos::misdesigned-forward-referenced-class :superclass clos::potential-class)

(:mop-direct clos:class :superclass clos::potential-class)
(:mop-direct clos::slotted-class :superclass clos:class)
(:mop-direct clos:built-in-class :superclass clos:class)
(:mop-direct clos:class :package-name "CLOS")
(:mop-direct clos:class :precedance
 (clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:class :classof clos:standard-class)
(:mop-direct clos:class :typeof clos:standard-class)
(:mop-direct clos:class :superclass clos::potential-class)
(:mop-direct clos:class :slot ((:name clos::$direct-superclasses) (:ordinal 1) (:type common-lisp:list) (:initargs (:direct-superclasses))))
(:mop-direct clos:class :slot ((:name clos::$all-superclasses) (:ordinal 2) (:type common-lisp:hash-table)))
(:mop-direct clos:class :slot ((:name clos::$precedence-list) (:ordinal 3) (:type common-lisp:list)))
(:mop-direct clos:class :slot ((:name clos::$direct-slots) (:ordinal 4) (:type common-lisp:list) (:initargs (:direct-slots))))
(:mop-direct clos:class :slot ((:name clos::$slots) (:ordinal 5) (:type common-lisp:list)))
(:mop-direct clos:class :slot ((:name clos::$slot-location-table) (:ordinal 6) (:initform clos::empty-ht) (:type common-lisp:hash-table)))
(:mop-direct clos:class :slot
 ((:name clos::$direct-default-initargs) (:ordinal 7) (:type common-lisp:list) (:initargs (:direct-default-initargs))))
(:mop-direct clos:class :slot ((:name clos::$default-initargs) (:ordinal 8)))
(:mop-direct clos:class :slot
 ((:name clos::$documentation) (:ordinal 9) (:type (common-lisp:or common-lisp:string common-lisp:null)) (:initargs (:documentation))))
(:mop-direct clos:class :slot ((:name clos::$listeners) (:ordinal 10) (:type common-lisp:list)))
(:mop-direct clos:class :slot ((:name clos::$initialized) (:ordinal 11) (:initform 0) (:type (common-lisp:integer 0 6))))
(:mop-direct clos::slotted-class :superclass clos:class)
(:mop-direct clos:structure-class :superclass clos::slotted-class)
(:mop-direct clos::semi-standard-class :superclass clos::slotted-class)
(:mop-direct clos::slotted-class :package-name "CLOS")
(:mop-direct clos::slotted-class :precedance
 (clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject common-lisp:standard-object
  common-lisp:t))
(:mop-direct clos::slotted-class :classof clos:standard-class)
(:mop-direct clos::slotted-class :typeof clos:standard-class)
(:mop-direct clos::slotted-class :superclass clos:class)
(:mop-direct clos::slotted-class :slot ((:name clos::$subclass-of-stablehash-p) (:ordinal 1) (:type common-lisp:boolean)))
(:mop-direct clos::slotted-class :slot ((:name clos::$generic-accessors) (:ordinal 2) (:initform common-lisp:t)))
(:mop-direct clos::slotted-class :slot ((:name clos::$direct-accessors) (:ordinal 3) (:initform 'common-lisp:nil) (:type common-lisp:list)))
(:mop-direct clos::slotted-class :slot ((:name clos::$valid-initargs-from-slots) (:ordinal 4) (:type common-lisp:list)))
(:mop-direct clos::slotted-class :slot ((:name clos::$instance-size) (:ordinal 5) (:type (common-lisp:integer 1 common-lisp:*))))
(:mop-direct clos:structure-class :superclass clos::slotted-class)
(:mop-direct clos:structure-class :package-name "CLOS")
(:mop-direct clos:structure-class :precedance
 (clos::slotted-class clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos:structure-class :classof clos:standard-class)
(:mop-direct clos:structure-class :typeof clos:standard-class)
(:mop-direct clos:structure-class :superclass clos::slotted-class)
(:mop-direct clos:structure-class :slot ((:name clos::$names) (:ordinal 1) (:type common-lisp:cons)))
(:mop-direct clos:structure-class :slot ((:name clos::$kconstructor) (:ordinal 2) (:type common-lisp:symbol)))
(:mop-direct clos:structure-class :slot ((:name clos::$boa-constructors) (:ordinal 3) (:type common-lisp:list)))
(:mop-direct clos:structure-class :slot ((:name clos::$copier) (:ordinal 4) (:type common-lisp:symbol)))
(:mop-direct clos:structure-class :slot ((:name clos::$predicate) (:ordinal 5) (:type common-lisp:symbol)))
(:mop-direct clos:structure-class :slot
 ((:name clos::$prototype) (:ordinal 6) (:type (common-lisp:or common-lisp:structure-object common-lisp:null))))
(:mop-direct clos:structure-class :prototype #<clos:structure-class #<unbound>>)
(:mop-direct clos::semi-standard-class :superclass clos::slotted-class)
(:mop-direct clos:funcallable-standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:standard-class :superclass clos::semi-standard-class)
(:mop-direct clos::semi-standard-class :default-initargs
 ((:fixed-slot-locations common-lisp:nil #<compiled-function clos::constant-initfunction>)))
(:mop-direct clos::semi-standard-class :package-name "CLOS")
(:mop-direct clos::semi-standard-class :precedance
 (clos::slotted-class clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject
  common-lisp:standard-object common-lisp:t))
(:mop-direct clos::semi-standard-class :classof clos:standard-class)
(:mop-direct clos::semi-standard-class :typeof clos:standard-class)
(:mop-direct clos::semi-standard-class :superclass clos::slotted-class)
(:mop-direct clos::semi-standard-class :slot ((:name clos::$current-version) (:ordinal 1) (:type common-lisp:simple-vector)))
(:mop-direct clos::semi-standard-class :slot ((:name clos::$funcallablep) (:ordinal 2) (:type common-lisp:boolean)))
(:mop-direct clos::semi-standard-class :slot ((:name clos::$fixed-slot-locations) (:ordinal 3) (:initargs (:fixed-slot-locations))))
(:mop-direct clos::semi-standard-class :slot ((:name clos::$instantiated) (:ordinal 4) (:type common-lisp:boolean)))
(:mop-direct clos::semi-standard-class :slot
 ((:name clos::$direct-instance-specializers) (:ordinal 5) (:type (common-lisp:or common-lisp:hash-table clos::weak-list common-lisp:null))))
(:mop-direct clos::semi-standard-class :slot
 ((:name clos::$finalized-direct-subclasses) (:ordinal 6) (:initform 'common-lisp:nil)
  (:type (common-lisp:or common-lisp:hash-table clos::weak-list common-lisp:null))))
(:mop-direct clos::semi-standard-class :slot
 ((:name clos::$prototype) (:ordinal 7) (:type (common-lisp:or common-lisp:standard-object common-lisp:null))))
(:mop-direct clos:funcallable-standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:funcallable-standard-class :default-initargs
 ((:fixed-slot-locations common-lisp:nil #<compiled-function clos::constant-initfunction>)))
(:mop-direct clos:funcallable-standard-class :package-name "CLOS")
(:mop-direct clos:funcallable-standard-class :precedance
 (clos::semi-standard-class clos::slotted-class clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash
  clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:funcallable-standard-class :classof clos:standard-class)
(:mop-direct clos:funcallable-standard-class :typeof clos:standard-class)
(:mop-direct clos:funcallable-standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:funcallable-standard-class :prototype #<clos:funcallable-standard-class #<unbound> :uninitialized>)
(:mop-direct clos:standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:standard-class :default-initargs ((:fixed-slot-locations common-lisp:nil #<compiled-function clos::constant-initfunction>)))
(:mop-direct clos:standard-class :package-name "CLOS")
(:mop-direct clos:standard-class :precedance
 (clos::semi-standard-class clos::slotted-class clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash
  clos:metaobject common-lisp:standard-object common-lisp:t))
(:mop-direct clos:standard-class :superclass clos::semi-standard-class)
(:mop-direct clos:standard-class :prototype #<clos:standard-class #<unbound> :uninitialized>)
(:mop-direct clos::semi-standard-class :prototype #<clos::semi-standard-class #<unbound> :uninitialized>)
(:mop-direct clos::slotted-class :prototype #<clos::slotted-class #<unbound>>)
(:mop-direct clos:built-in-class :superclass clos:class)
(:mop-direct clos:built-in-class :package-name "CLOS")
(:mop-direct clos:built-in-class :precedance
 (clos:class clos::potential-class clos:specializer clos::super-class clos:standard-stablehash clos:metaobject common-lisp:standard-object
  common-lisp:t))
(:mop-direct clos:built-in-class :classof clos:standard-class)
(:mop-direct clos:built-in-class :typeof clos:standard-class)
(:mop-direct clos:built-in-class :superclass clos:class)
(:mop-direct clos:built-in-class :slot ((:name clos::$prototype) (:ordinal 1)))
(:mop-direct clos:built-in-class :prototype #<clos:built-in-class #<unbound>>)
(:mop-direct clos:class :prototype #<clos:class #<unbound>>)
(:mop-direct clos::potential-class :prototype #<clos::potential-class #<unbound>>)
(:mop-direct clos:specializer :prototype #<clos:specializer #x000335969C58>)
(:mop-direct clos:metaobject :prototype #<clos:metaobject #x000335A8C9E8>)
(:mop-direct ql-impl:abcl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:abcl :package-name "QL-IMPL")
(:mop-direct ql-impl:abcl :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-impl:abcl :classof clos:standard-class)
(:mop-direct ql-impl:abcl :typeof clos:standard-class)
(:mop-direct ql-impl:abcl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:abcl :prototype #<ql-impl:abcl #x000335A92C10>)
(:mop-direct ql-impl:ccl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:ccl :package-name "QL-IMPL")
(:mop-direct ql-impl:ccl :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-impl:ccl :classof clos:standard-class)
(:mop-direct ql-impl:ccl :typeof clos:standard-class)
(:mop-direct ql-impl:ccl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:ccl :prototype #<ql-impl:ccl #x000335A98E38>)
(:mop-direct ql-impl:clasp :superclass common-lisp:standard-object)
(:mop-direct ql-impl:clasp :package-name "QL-IMPL")
(:mop-direct ql-impl:clasp :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-impl:clasp :classof clos:standard-class)
(:mop-direct ql-impl:clasp :typeof clos:standard-class)
(:mop-direct ql-impl:clasp :superclass common-lisp:standard-object)
(:mop-direct ql-impl:clasp :prototype #<ql-impl:clasp #x000335A9F200>)
(:mop-direct ql-impl:clisp :superclass common-lisp:standard-object)
(:mop-direct ql-impl:clisp :package-name "QL-IMPL")
(:mop-direct ql-impl:clisp :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-impl:clisp :classof clos:standard-class)
(:mop-direct ql-impl:clisp :typeof clos:standard-class)
(:mop-direct ql-impl:clisp :superclass common-lisp:standard-object)
(:mop-direct ql-impl:clisp :prototype #<ql-impl:clisp #x000335AA55C8>)
(:mop-direct ql-impl:cmucl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:cmucl :package-name "QL-IMPL")
(:mop-direct ql-impl:cmucl :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-impl:cmucl :classof clos:standard-class)
(:mop-direct ql-impl:cmucl :typeof clos:standard-class)
(:mop-direct ql-impl:cmucl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:cmucl :prototype #<ql-impl:cmucl #x000335AAB990>)
(:mop-direct ql-impl:scl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:scl :package-name "QL-IMPL")
(:mop-direct ql-impl:scl :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-impl:scl :classof clos:standard-class)
(:mop-direct ql-impl:scl :typeof clos:standard-class)
(:mop-direct ql-impl:scl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:scl :prototype #<ql-impl:scl #x000335AB1BB8>)
(:mop-direct ql-impl:lispworks :superclass common-lisp:standard-object)
(:mop-direct ql-impl:lispworks :package-name "QL-IMPL")
(:mop-direct ql-impl:lispworks :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-impl:lispworks :classof clos:standard-class)
(:mop-direct ql-impl:lispworks :typeof clos:standard-class)
(:mop-direct ql-impl:lispworks :superclass common-lisp:standard-object)
(:mop-direct ql-impl:lispworks :prototype #<ql-impl:lispworks #x000335AB7F80>)
(:mop-direct ql-impl:ecl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:ecl :package-name "QL-IMPL")
(:mop-direct ql-impl:ecl :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-impl:ecl :classof clos:standard-class)
(:mop-direct ql-impl:ecl :typeof clos:standard-class)
(:mop-direct ql-impl:ecl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:ecl :prototype #<ql-impl:ecl #x000335ABE1A8>)
(:mop-direct ql-impl:mkcl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:mkcl :package-name "QL-IMPL")
(:mop-direct ql-impl:mkcl :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-impl:mkcl :classof clos:standard-class)
(:mop-direct ql-impl:mkcl :typeof clos:standard-class)
(:mop-direct ql-impl:mkcl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:mkcl :prototype #<ql-impl:mkcl #x000335AC43D0>)
(:mop-direct ql-impl:sbcl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:sbcl :package-name "QL-IMPL")
(:mop-direct ql-impl:sbcl :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-impl:sbcl :classof clos:standard-class)
(:mop-direct ql-impl:sbcl :typeof clos:standard-class)
(:mop-direct ql-impl:sbcl :superclass common-lisp:standard-object)
(:mop-direct ql-impl:sbcl :prototype #<ql-impl:sbcl #x000335ACA5F8>)
(:mop-direct ql-progress::progress-bar :superclass common-lisp:standard-object)
(:mop-direct ql-progress::uncertain-size-progress-bar :superclass ql-progress::progress-bar)
(:mop-direct ql-progress::progress-bar :default-initargs
 ((:progress-character #\= #<compiled-function clos::constant-initfunction>)
  (:character-count 50 #<compiled-function clos::constant-initfunction>) (:characters-so-far 0 #<compiled-function clos::constant-initfunction>)
  (:update-interval (common-lisp:floor common-lisp:internal-time-units-per-second 4) #<compiled-function clos::constant-initfunction>)
  (:last-update-time 0 #<compiled-function clos::constant-initfunction>) (:total 0 #<compiled-function clos::constant-initfunction>)
  (:progress 0 #<compiled-function clos::constant-initfunction>) (:pending 0 #<compiled-function clos::constant-initfunction>)))
(:mop-direct ql-progress::progress-bar :package-name "QL-PROGRESS")
(:mop-direct ql-progress::progress-bar :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-progress::progress-bar :classof clos:standard-class)
(:mop-direct ql-progress::progress-bar :typeof clos:standard-class)
(:mop-direct ql-progress::progress-bar :superclass common-lisp:standard-object)
(:mop-direct ql-progress::progress-bar :slot
 ((:name ql-progress::start-time) (:ordinal 1) (:initargs (:start-time)) (:readers (ql-progress::start-time))
  (:writers ((common-lisp:setf ql-progress::start-time)))))
(:mop-direct ql-progress::progress-bar :slot
 ((:name ql-progress::end-time) (:ordinal 2) (:initargs (:end-time)) (:readers (ql-progress::end-time))
  (:writers ((common-lisp:setf ql-progress::end-time)))))
(:mop-direct ql-progress::progress-bar :slot
 ((:name ql-progress::progress-character) (:ordinal 3) (:initargs (:progress-character)) (:readers (ql-progress::progress-character))
  (:writers ((common-lisp:setf ql-progress::progress-character)))))
(:mop-direct ql-progress::progress-bar :slot
 ((:name ql-progress::character-count) (:ordinal 4) (:initargs (:character-count)) (:readers (ql-progress::character-count))
  (:writers ((common-lisp:setf ql-progress::character-count)))))
(:mop-direct ql-progress::progress-bar :slot
 ((:name ql-progress::characters-so-far) (:ordinal 5) (:initargs (:characters-so-far)) (:readers (ql-progress::characters-so-far))
  (:writers ((common-lisp:setf ql-progress::characters-so-far)))))
(:mop-direct ql-progress::progress-bar :slot
 ((:name ql-progress::update-interval) (:ordinal 6) (:initargs (:update-interval)) (:readers (ql-progress::update-interval))
  (:writers ((common-lisp:setf ql-progress::update-interval)))))
(:mop-direct ql-progress::progress-bar :slot
 ((:name ql-progress::last-update-time) (:ordinal 7) (:initargs (:last-update-time)) (:readers (ql-progress::last-update-time))
  (:writers ((common-lisp:setf ql-progress::last-update-time)))))
(:mop-direct ql-progress::progress-bar :slot
 ((:name ql-progress::total) (:ordinal 8) (:initargs (:total)) (:readers (ql-progress::total))
  (:writers ((common-lisp:setf ql-progress::total)))))
(:mop-direct ql-progress::progress-bar :slot
 ((:name ql-progress::progress) (:ordinal 9) (:initargs (:progress)) (:readers (ql-progress::progress))
  (:writers ((common-lisp:setf ql-progress::progress)))))
(:mop-direct ql-progress::progress-bar :slot
 ((:name ql-progress::pending) (:ordinal 10) (:initargs (:pending)) (:readers (ql-progress::pending))
  (:writers ((common-lisp:setf ql-progress::pending)))))
(:mop-direct ql-progress::uncertain-size-progress-bar :superclass ql-progress::progress-bar)
(:mop-direct ql-progress::uncertain-size-progress-bar :default-initargs
 ((:total 0 #<compiled-function clos::constant-initfunction>) (:progress-char-index 0 #<compiled-function clos::constant-initfunction>)
  (:units-per-char (common-lisp:floor (common-lisp:expt 1024 2) 50) #<compiled-function ql-progress::default-units-per-char>)
  (:progress-character #\= #<compiled-function clos::constant-initfunction>)
  (:character-count 50 #<compiled-function clos::constant-initfunction>) (:characters-so-far 0 #<compiled-function clos::constant-initfunction>)
  (:update-interval (common-lisp:floor common-lisp:internal-time-units-per-second 4) #<compiled-function clos::constant-initfunction>)
  (:last-update-time 0 #<compiled-function clos::constant-initfunction>) (:progress 0 #<compiled-function clos::constant-initfunction>)
  (:pending 0 #<compiled-function clos::constant-initfunction>)))
(:mop-direct ql-progress::uncertain-size-progress-bar :package-name "QL-PROGRESS")
(:mop-direct ql-progress::uncertain-size-progress-bar :precedance (ql-progress::progress-bar common-lisp:standard-object common-lisp:t))
(:mop-direct ql-progress::uncertain-size-progress-bar :classof clos:standard-class)
(:mop-direct ql-progress::uncertain-size-progress-bar :typeof clos:standard-class)
(:mop-direct ql-progress::uncertain-size-progress-bar :superclass ql-progress::progress-bar)
(:mop-direct ql-progress::uncertain-size-progress-bar :slot
 ((:name ql-progress::progress-char-index) (:ordinal 1) (:initargs (:progress-char-index)) (:readers (ql-progress::progress-char-index))
  (:writers ((common-lisp:setf ql-progress::progress-char-index)))))
(:mop-direct ql-progress::uncertain-size-progress-bar :slot
 ((:name ql-progress::units-per-char) (:ordinal 2) (:initargs (:units-per-char)) (:readers (ql-progress::units-per-char))
  (:writers ((common-lisp:setf ql-progress::units-per-char)))))
(:mop-direct ql-progress::uncertain-size-progress-bar :prototype #<ql-progress::uncertain-size-progress-bar #x000335B02090>)
(:mop-direct ql-progress::progress-bar :prototype #<ql-progress::progress-bar #x000335B04EE8>)
(:mop-direct ql-http::matcher :superclass common-lisp:standard-object)
(:mop-direct ql-http::matcher :package-name "QL-HTTP")
(:mop-direct ql-http::matcher :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-http::matcher :classof clos:standard-class)
(:mop-direct ql-http::matcher :typeof clos:standard-class)
(:mop-direct ql-http::matcher :superclass common-lisp:standard-object)
(:mop-direct ql-http::matcher :slot ((:name ql-http::pattern) (:ordinal 1) (:initargs (:pattern)) (:readers (ql-http::pattern))))
(:mop-direct ql-http::matcher :slot
 ((:name ql-http::pos) (:ordinal 2) (:initform 0) (:readers (ql-http::match-pos)) (:writers ((common-lisp:setf ql-http::match-pos)))))
(:mop-direct ql-http::matcher :slot
 ((:name ql-http::matchedp) (:ordinal 3) (:readers (ql-http::matchedp)) (:writers ((common-lisp:setf ql-http::matchedp)))))
(:mop-direct ql-http::matcher :prototype #<ql-http::matcher #x000335B11AE8>)
(:mop-direct ql-http::cbuf :superclass common-lisp:standard-object)
(:mop-direct ql-http::cbuf :default-initargs
 ((:data (ql-http::make-octet-vector ql-http::*cbuf-buffer-size*) #<compiled-function ql-http::default-data>)
  (:connection common-lisp:nil #<compiled-function clos::constant-initfunction>) (:start 0 #<compiled-function clos::constant-initfunction>)
  (:end 0 #<compiled-function clos::constant-initfunction>) (:eofp common-lisp:nil #<compiled-function clos::constant-initfunction>)))
(:mop-direct ql-http::cbuf :package-name "QL-HTTP")
(:mop-direct ql-http::cbuf :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-http::cbuf :classof clos:standard-class)
(:mop-direct ql-http::cbuf :typeof clos:standard-class)
(:mop-direct ql-http::cbuf :superclass common-lisp:standard-object)
(:mop-direct ql-http::cbuf :slot
 ((:name ql-http::data) (:ordinal 1) (:initargs (:data)) (:readers (ql-http::data)) (:writers ((common-lisp:setf ql-http::data)))))
(:mop-direct ql-http::cbuf :slot
 ((:name ql-http::connection) (:ordinal 2) (:initargs (:connection)) (:readers (ql-http::connection))
  (:writers ((common-lisp:setf ql-http::connection)))))
(:mop-direct ql-http::cbuf :slot
 ((:name ql-http::start) (:ordinal 3) (:initargs (:start)) (:readers (ql-http::start)) (:writers ((common-lisp:setf ql-http::start)))))
(:mop-direct ql-http::cbuf :slot
 ((:name ql-http::end) (:ordinal 4) (:initargs (:end)) (:readers (ql-http::end)) (:writers ((common-lisp:setf ql-http::end)))))
(:mop-direct ql-http::cbuf :slot
 ((:name ql-http::eofp) (:ordinal 5) (:initargs (:eofp)) (:readers (ql-http::eofp)) (:writers ((common-lisp:setf ql-http::eofp)))))
(:mop-direct ql-http::cbuf :prototype #<ql-http::cbuf #x000335974D88>)
(:mop-direct ql-http::octet-sink :superclass common-lisp:standard-object)
(:mop-direct ql-http::octet-sink :default-initargs
 ((:storage (common-lisp:make-array 1024 :element-type 'ql-http::octet :fill-pointer 0 :adjustable common-lisp:t)
   #<compiled-function ql-http::default-storage>)))
(:mop-direct ql-http::octet-sink :package-name "QL-HTTP")
(:mop-direct ql-http::octet-sink :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-http::octet-sink :classof clos:standard-class)
(:mop-direct ql-http::octet-sink :typeof clos:standard-class)
(:mop-direct ql-http::octet-sink :superclass common-lisp:standard-object)
(:mop-direct ql-http::octet-sink :slot
 ((:name ql-http::storage) (:ordinal 1) (:initargs (:storage)) (:readers (ql-http::storage)) (:writers ((common-lisp:setf ql-http::storage)))))
(:mop-direct ql-http::octet-sink :prototype #<ql-http::octet-sink #x00033597FD78>)
(:mop-direct ql-http::header :superclass common-lisp:standard-object)
(:mop-direct ql-http::header :package-name "QL-HTTP")
(:mop-direct ql-http::header :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-http::header :classof clos:standard-class)
(:mop-direct ql-http::header :typeof clos:standard-class)
(:mop-direct ql-http::header :superclass common-lisp:standard-object)
(:mop-direct ql-http::header :slot
 ((:name ql-http::data) (:ordinal 1) (:initargs (:data)) (:readers (ql-http::data)) (:writers ((common-lisp:setf ql-http::data)))))
(:mop-direct ql-http::header :slot
 ((:name ql-http::status) (:ordinal 2) (:initargs (:status)) (:readers (ql-http::status)) (:writers ((common-lisp:setf ql-http::status)))))
(:mop-direct ql-http::header :slot
 ((:name ql-http::name-starts) (:ordinal 3) (:initargs (:name-starts)) (:readers (ql-http::name-starts))
  (:writers ((common-lisp:setf ql-http::name-starts)))))
(:mop-direct ql-http::header :slot
 ((:name ql-http::name-ends) (:ordinal 4) (:initargs (:name-ends)) (:readers (ql-http::name-ends))
  (:writers ((common-lisp:setf ql-http::name-ends)))))
(:mop-direct ql-http::header :slot
 ((:name ql-http::value-starts) (:ordinal 5) (:initargs (:value-starts)) (:readers (ql-http::value-starts))
  (:writers ((common-lisp:setf ql-http::value-starts)))))
(:mop-direct ql-http::header :slot
 ((:name ql-http::value-ends) (:ordinal 6) (:initargs (:value-ends)) (:readers (ql-http::value-ends))
  (:writers ((common-lisp:setf ql-http::value-ends)))))

(:mop-direct ql-http:url :superclass common-lisp:standard-object)
(:mop-direct ql-http:url :package-name "QL-HTTP")
(:mop-direct ql-http:url :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-http:url :classof clos:standard-class)
(:mop-direct ql-http:url :typeof clos:standard-class)
(:mop-direct ql-http:url :superclass common-lisp:standard-object)
(:mop-direct ql-http:url :slot
 ((:name ql-http:scheme) (:ordinal 1) (:initargs (:scheme)) (:readers (ql-http:scheme)) (:writers ((common-lisp:setf ql-http:scheme)))))
(:mop-direct ql-http:url :slot
 ((:name ql-http:hostname) (:ordinal 2) (:initargs (:hostname)) (:readers (ql-http:hostname)) (:writers ((common-lisp:setf ql-http:hostname)))))
(:mop-direct ql-http:url :slot
 ((:name ql-http:port) (:ordinal 3) (:initargs (:port)) (:readers (ql-http:port)) (:writers ((common-lisp:setf ql-http:port)))))
(:mop-direct ql-http:url :slot
 ((:name ql-http:path) (:ordinal 4) (:initform "/") (:initargs (:path)) (:readers (ql-http:path)) (:writers ((common-lisp:setf ql-http:path)))))

(:mop-direct ql-cdb::record-pointer :superclass common-lisp:standard-object)
(:mop-direct ql-cdb::record-pointer :default-initargs
 ((:hash-value 0 #<compiled-function clos::constant-initfunction>) (:record-position 0 #<compiled-function clos::constant-initfunction>)))
(:mop-direct ql-cdb::record-pointer :package-name "QL-CDB")
(:mop-direct ql-cdb::record-pointer :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-cdb::record-pointer :classof clos:standard-class)
(:mop-direct ql-cdb::record-pointer :typeof clos:standard-class)
(:mop-direct ql-cdb::record-pointer :superclass common-lisp:standard-object)
(:mop-direct ql-cdb::record-pointer :slot
 ((:name ql-cdb::hash-value) (:ordinal 1) (:initargs (:hash-value)) (:readers (ql-cdb::hash-value))
  (:writers ((common-lisp:setf ql-cdb::hash-value)))))
(:mop-direct ql-cdb::record-pointer :slot
 ((:name ql-cdb::record-position) (:ordinal 2) (:initargs (:record-position)) (:readers (ql-cdb::record-position))
  (:writers ((common-lisp:setf ql-cdb::record-position)))))

(:mop-direct ql-cdb::hash-table-bucket :superclass common-lisp:standard-object)
(:mop-direct ql-cdb::hash-table-bucket :default-initargs
 ((:table-position 0 #<compiled-function clos::constant-initfunction>)
  (:entries (ql-cdb::make-growable-vector) #<compiled-function ql-cdb::default-entries>)))
(:mop-direct ql-cdb::hash-table-bucket :package-name "QL-CDB")
(:mop-direct ql-cdb::hash-table-bucket :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-cdb::hash-table-bucket :classof clos:standard-class)
(:mop-direct ql-cdb::hash-table-bucket :typeof clos:standard-class)
(:mop-direct ql-cdb::hash-table-bucket :superclass common-lisp:standard-object)
(:mop-direct ql-cdb::hash-table-bucket :slot
 ((:name ql-cdb::table-position) (:ordinal 1) (:initargs (:table-position)) (:readers (ql-cdb::table-position))
  (:writers ((common-lisp:setf ql-cdb::table-position)))))
(:mop-direct ql-cdb::hash-table-bucket :slot
 ((:name ql-cdb::entries) (:ordinal 2) (:initargs (:entries)) (:readers (ql-cdb::entries)) (:writers ((common-lisp:setf ql-cdb::entries)))))

(:mop-direct ql-cdb::cdb-writer :superclass common-lisp:standard-object)
(:mop-direct ql-cdb::cdb-writer :default-initargs
 ((:end-of-records-position 2048 #<compiled-function clos::constant-initfunction>)
  (:buckets
   (common-lisp:map-into (common-lisp:make-array 256) (common-lisp:lambda common-lisp:nil (clos:make-instance 'ql-cdb::hash-table-bucket)))
   #<compiled-function ql-cdb::default-buckets>)))
(:mop-direct ql-cdb::cdb-writer :package-name "QL-CDB")
(:mop-direct ql-cdb::cdb-writer :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-cdb::cdb-writer :classof clos:standard-class)
(:mop-direct ql-cdb::cdb-writer :typeof clos:standard-class)
(:mop-direct ql-cdb::cdb-writer :superclass common-lisp:standard-object)
(:mop-direct ql-cdb::cdb-writer :slot
 ((:name ql-cdb::buckets) (:ordinal 1) (:initargs (:buckets)) (:readers (ql-cdb::buckets)) (:writers ((common-lisp:setf ql-cdb::buckets)))))
(:mop-direct ql-cdb::cdb-writer :slot
 ((:name ql-cdb::end-of-records-position) (:ordinal 2) (:initargs (:end-of-records-position)) (:readers (ql-cdb::end-of-records-position))
  (:writers ((common-lisp:setf ql-cdb::end-of-records-position)))))
(:mop-direct ql-cdb::cdb-writer :slot
 ((:name ql-cdb::output) (:ordinal 3) (:initargs (:output)) (:readers (ql-cdb::output)) (:writers ((common-lisp:setf ql-cdb::output)))))
(:mop-direct ql-cdb::cdb-writer :prototype #<ql-cdb::cdb-writer #x0003359E1138>)
(:mop-direct ql-dist:dist :superclass common-lisp:standard-object)
(:mop-direct ql-dist:dist :default-initargs
 ((:name "unnamed" #<compiled-function clos::constant-initfunction>) (:version "unknown" #<compiled-function clos::constant-initfunction>)
  (:distinfo-subscription-url common-lisp:nil #<compiled-function clos::constant-initfunction>)))
(:mop-direct ql-dist:dist :package-name "QL-DIST")
(:mop-direct ql-dist:dist :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-dist:dist :classof clos:standard-class)
(:mop-direct ql-dist:dist :typeof clos:standard-class)
(:mop-direct ql-dist:dist :superclass common-lisp:standard-object)
(:mop-direct ql-dist:dist :slot
 ((:name ql-dist:base-directory) (:ordinal 1) (:initargs (:base-directory)) (:readers (ql-dist:base-directory))
  (:writers ((common-lisp:setf ql-dist:base-directory)))))
(:mop-direct ql-dist:dist :slot
 ((:name ql-dist:name) (:ordinal 2) (:initargs (:name)) (:readers (ql-dist:name)) (:writers ((common-lisp:setf ql-dist:name)))))
(:mop-direct ql-dist:dist :slot
 ((:name ql-dist:version) (:ordinal 3) (:initargs (:version)) (:readers (ql-dist:version)) (:writers ((common-lisp:setf ql-dist:version)))))
(:mop-direct ql-dist:dist :slot
 ((:name ql-dist:system-index-url) (:ordinal 4) (:initargs (:system-index-url)) (:readers (ql-dist:system-index-url))
  (:writers ((common-lisp:setf ql-dist:system-index-url)))))
(:mop-direct ql-dist:dist :slot
 ((:name ql-dist:release-index-url) (:ordinal 5) (:initargs (:release-index-url)) (:readers (ql-dist:release-index-url))
  (:writers ((common-lisp:setf ql-dist:release-index-url)))))
(:mop-direct ql-dist:dist :slot
 ((:name ql-dist:available-versions-url) (:ordinal 6) (:initargs (:available-versions-url)) (:readers (ql-dist:available-versions-url))
  (:writers ((common-lisp:setf ql-dist:available-versions-url)))))
(:mop-direct ql-dist:dist :slot
 ((:name ql-dist::archive-base-url) (:ordinal 7) (:initargs (:archive-base-url)) (:readers (ql-dist::archive-base-url))
  (:writers ((common-lisp:setf ql-dist::archive-base-url)))))
(:mop-direct ql-dist:dist :slot
 ((:name ql-dist:canonical-distinfo-url) (:ordinal 8) (:initargs (:canonical-distinfo-url)) (:readers (ql-dist:canonical-distinfo-url))
  (:writers ((common-lisp:setf ql-dist:canonical-distinfo-url)))))
(:mop-direct ql-dist:dist :slot
 ((:name ql-dist::distinfo-subscription-url) (:ordinal 9) (:initargs (:distinfo-subscription-url))
  (:readers (ql-dist::distinfo-subscription-url)) (:writers ((common-lisp:setf ql-dist::distinfo-subscription-url)))))
(:mop-direct ql-dist:dist :slot
 ((:name ql-dist::system-index) (:ordinal 10) (:initargs (:system-index)) (:readers (ql-dist::system-index))
  (:writers ((common-lisp:setf ql-dist::system-index)))))
(:mop-direct ql-dist:dist :slot
 ((:name ql-dist::release-index) (:ordinal 11) (:initargs (:release-index)) (:readers (ql-dist::release-index))
  (:writers ((common-lisp:setf ql-dist::release-index)))))
(:mop-direct ql-dist:dist :slot
 ((:name ql-dist:provided-systems) (:ordinal 12) (:initargs (:provided-systems)) (:readers (ql-dist:provided-systems))
  (:writers ((common-lisp:setf ql-dist:provided-systems)))))
(:mop-direct ql-dist:dist :slot
 ((:name ql-dist:provided-releases) (:ordinal 13) (:initargs (:provided-releases)) (:readers (ql-dist:provided-releases))
  (:writers ((common-lisp:setf ql-dist:provided-releases)))))
(:mop-direct ql-dist:dist :slot
 ((:name ql-dist::local-distinfo-file) (:ordinal 14) (:initargs (:local-distinfo-file)) (:readers (ql-dist::local-distinfo-file))
  (:writers ((common-lisp:setf ql-dist::local-distinfo-file)))))

(:mop-direct ql-dist::preference-mixin :superclass common-lisp:standard-object)
(:mop-direct ql-dist:system :superclass ql-dist::preference-mixin)
(:mop-direct ql-dist:release :superclass ql-dist::preference-mixin)
(:mop-direct ql-dist::preference-mixin :package-name "QL-DIST")
(:mop-direct ql-dist::preference-mixin :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-dist::preference-mixin :classof clos:standard-class)
(:mop-direct ql-dist::preference-mixin :typeof clos:standard-class)
(:mop-direct ql-dist::preference-mixin :superclass common-lisp:standard-object)
(:mop-direct ql-dist:system :superclass ql-dist::preference-mixin)
(:mop-direct ql-dist:system :default-initargs ((:metadata-name "systems" #<compiled-function clos::constant-initfunction>)))
(:mop-direct ql-dist:system :package-name "QL-DIST")
(:mop-direct ql-dist:system :precedance (ql-dist::preference-mixin common-lisp:standard-object common-lisp:t))
(:mop-direct ql-dist:system :classof clos:standard-class)
(:mop-direct ql-dist:system :typeof clos:standard-class)
(:mop-direct ql-dist:system :superclass ql-dist::preference-mixin)
(:mop-direct ql-dist:system :slot
 ((:name ql-dist:name) (:ordinal 1) (:initargs (:name)) (:readers (ql-dist:name ql-dist:short-description))
  (:writers ((common-lisp:setf ql-dist:name)))))
(:mop-direct ql-dist:system :slot
 ((:name ql-dist:system-file-name) (:ordinal 2) (:initargs (:system-file-name)) (:readers (ql-dist:system-file-name))
  (:writers ((common-lisp:setf ql-dist:system-file-name)))))
(:mop-direct ql-dist:system :slot
 ((:name ql-dist:release) (:ordinal 3) (:initargs (:release)) (:readers (ql-dist:release ql-dist:preference-parent))
  (:writers ((common-lisp:setf ql-dist:release)))))
(:mop-direct ql-dist:system :slot
 ((:name ql-dist:dist) (:ordinal 4) (:initargs (:dist)) (:readers (ql-dist:dist)) (:writers ((common-lisp:setf ql-dist:dist)))))
(:mop-direct ql-dist:system :slot
 ((:name ql-dist:required-systems) (:ordinal 5) (:initargs (:required-systems)) (:readers (ql-dist:required-systems))
  (:writers ((common-lisp:setf ql-dist:required-systems)))))
(:mop-direct ql-dist:system :slot
 ((:name ql-dist:metadata-name) (:ordinal 6) (:initargs (:metadata-name)) (:readers (ql-dist:metadata-name))
  (:writers ((common-lisp:setf ql-dist:metadata-name)))))

(:mop-direct ql-dist:release :superclass ql-dist::preference-mixin)
(:mop-direct ql-dist:release :default-initargs ((:metadata-name "releases" #<compiled-function clos::constant-initfunction>)))
(:mop-direct ql-dist:release :package-name "QL-DIST")
(:mop-direct ql-dist:release :precedance (ql-dist::preference-mixin common-lisp:standard-object common-lisp:t))
(:mop-direct ql-dist:release :classof clos:standard-class)
(:mop-direct ql-dist:release :typeof clos:standard-class)
(:mop-direct ql-dist:release :superclass ql-dist::preference-mixin)
(:mop-direct ql-dist:release :slot
 ((:name ql-dist:project-name) (:ordinal 1) (:initargs (:project-name)) (:readers (ql-dist:name ql-dist:project-name))
  (:writers ((common-lisp:setf ql-dist:name) (common-lisp:setf ql-dist:project-name)))))
(:mop-direct ql-dist:release :slot
 ((:name ql-dist:dist) (:ordinal 2) (:initargs (:dist)) (:readers (ql-dist:dist ql-dist:preference-parent))
  (:writers ((common-lisp:setf ql-dist:dist)))))
(:mop-direct ql-dist:release :slot
 ((:name ql-dist:provided-systems) (:ordinal 3) (:initargs (:provided-systems)) (:readers (ql-dist:provided-systems))
  (:writers ((common-lisp:setf ql-dist:provided-systems)))))
(:mop-direct ql-dist:release :slot
 ((:name ql-dist:archive-url) (:ordinal 4) (:initargs (:archive-url)) (:readers (ql-dist:archive-url))
  (:writers ((common-lisp:setf ql-dist:archive-url)))))
(:mop-direct ql-dist:release :slot
 ((:name ql-dist:archive-size) (:ordinal 5) (:initargs (:archive-size)) (:readers (ql-dist:archive-size))
  (:writers ((common-lisp:setf ql-dist:archive-size)))))
(:mop-direct ql-dist:release :slot
 ((:name ql-dist:archive-md5) (:ordinal 6) (:initargs (:archive-md5)) (:readers (ql-dist:archive-md5))
  (:writers ((common-lisp:setf ql-dist:archive-md5)))))
(:mop-direct ql-dist:release :slot
 ((:name ql-dist:archive-content-sha1) (:ordinal 7) (:initargs (:archive-content-sha1)) (:readers (ql-dist:archive-content-sha1))
  (:writers ((common-lisp:setf ql-dist:archive-content-sha1)))))
(:mop-direct ql-dist:release :slot
 ((:name ql-dist:prefix) (:ordinal 8) (:initargs (:prefix)) (:readers (ql-dist:prefix ql-dist:short-description))
  (:writers ((common-lisp:setf ql-dist:prefix)))))
(:mop-direct ql-dist:release :slot
 ((:name ql-dist:system-files) (:ordinal 9) (:initargs (:system-files)) (:readers (ql-dist:system-files))
  (:writers ((common-lisp:setf ql-dist:system-files)))))
(:mop-direct ql-dist:release :slot
 ((:name ql-dist:metadata-name) (:ordinal 10) (:initargs (:metadata-name)) (:readers (ql-dist:metadata-name))
  (:writers ((common-lisp:setf ql-dist:metadata-name)))))

(:mop-direct ql-dist::preference-mixin :prototype #<ql-dist::preference-mixin #x000335A51938>)
(:mop-direct quicklisp-client::load-strategy :superclass common-lisp:standard-object)
(:mop-direct quicklisp-client::load-strategy :package-name "QUICKLISP-CLIENT")
(:mop-direct quicklisp-client::load-strategy :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct quicklisp-client::load-strategy :classof clos:standard-class)
(:mop-direct quicklisp-client::load-strategy :typeof clos:standard-class)
(:mop-direct quicklisp-client::load-strategy :superclass common-lisp:standard-object)
(:mop-direct quicklisp-client::load-strategy :slot
 ((:name ql-dist:name) (:ordinal 1) (:initargs (:name)) (:readers (ql-dist:name)) (:writers ((common-lisp:setf ql-dist:name)))))
(:mop-direct quicklisp-client::load-strategy :slot
 ((:name quicklisp-client::asdf-systems) (:ordinal 2) (:initargs (:asdf-systems)) (:readers (quicklisp-client::asdf-systems))
  (:writers ((common-lisp:setf quicklisp-client::asdf-systems)))))
(:mop-direct quicklisp-client::load-strategy :slot
 ((:name quicklisp-client::quicklisp-systems) (:ordinal 3) (:initargs (:quicklisp-systems)) (:readers (quicklisp-client::quicklisp-systems))
  (:writers ((common-lisp:setf quicklisp-client::quicklisp-systems)))))

(:mop-direct quicklisp-client::client-file-info :superclass common-lisp:standard-object)
(:mop-direct quicklisp-client::client-tar-file-info :superclass quicklisp-client::client-file-info)
(:mop-direct quicklisp-client::setup-file-info :superclass quicklisp-client::client-file-info)
(:mop-direct quicklisp-client::asdf-file-info :superclass quicklisp-client::client-file-info)
(:mop-direct quicklisp-client::client-file-info :package-name "QUICKLISP-CLIENT")
(:mop-direct quicklisp-client::client-file-info :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct quicklisp-client::client-file-info :classof clos:standard-class)
(:mop-direct quicklisp-client::client-file-info :typeof clos:standard-class)
(:mop-direct quicklisp-client::client-file-info :superclass common-lisp:standard-object)
(:mop-direct quicklisp-client::client-file-info :slot
 ((:name quicklisp-client::plist-key) (:ordinal 1) (:initargs (:plist-key)) (:readers (quicklisp-client::plist-key))))
(:mop-direct quicklisp-client::client-file-info :slot
 ((:name quicklisp-client::file-url) (:ordinal 2) (:initargs (:url)) (:readers (quicklisp-client::file-url))))
(:mop-direct quicklisp-client::client-file-info :slot ((:name ql-dist:name) (:ordinal 3) (:initargs (:name)) (:readers (ql-dist:name))))
(:mop-direct quicklisp-client::client-file-info :slot
 ((:name quicklisp-client::size) (:ordinal 4) (:initargs (:size)) (:readers (quicklisp-client::size))))
(:mop-direct quicklisp-client::client-file-info :slot
 ((:name quicklisp-client::md5) (:ordinal 5) (:initargs (:md5)) (:readers (quicklisp-client::md5))))
(:mop-direct quicklisp-client::client-file-info :slot
 ((:name quicklisp-client::sha256) (:ordinal 6) (:initargs (:sha256)) (:readers (quicklisp-client::sha256))))
(:mop-direct quicklisp-client::client-file-info :slot
 ((:name quicklisp-client::plist) (:ordinal 7) (:initargs (:plist)) (:readers (quicklisp-client::plist))))
(:mop-direct quicklisp-client::client-tar-file-info :superclass quicklisp-client::client-file-info)
(:mop-direct quicklisp-client::client-tar-file-info :default-initargs
 ((:plist-key :client-tar #<compiled-function clos::constant-initfunction>)
  (:name "quicklisp.tar" #<compiled-function clos::constant-initfunction>)))
(:mop-direct quicklisp-client::client-tar-file-info :package-name "QUICKLISP-CLIENT")
(:mop-direct quicklisp-client::client-tar-file-info :precedance (quicklisp-client::client-file-info common-lisp:standard-object common-lisp:t))
(:mop-direct quicklisp-client::client-tar-file-info :classof clos:standard-class)
(:mop-direct quicklisp-client::client-tar-file-info :typeof clos:standard-class)
(:mop-direct quicklisp-client::client-tar-file-info :superclass quicklisp-client::client-file-info)

(:mop-direct quicklisp-client::setup-file-info :superclass quicklisp-client::client-file-info)
(:mop-direct quicklisp-client::setup-file-info :default-initargs
 ((:plist-key :setup #<compiled-function clos::constant-initfunction>) (:name "setup.lisp" #<compiled-function clos::constant-initfunction>)))
(:mop-direct quicklisp-client::setup-file-info :package-name "QUICKLISP-CLIENT")
(:mop-direct quicklisp-client::setup-file-info :precedance (quicklisp-client::client-file-info common-lisp:standard-object common-lisp:t))
(:mop-direct quicklisp-client::setup-file-info :classof clos:standard-class)
(:mop-direct quicklisp-client::setup-file-info :typeof clos:standard-class)
(:mop-direct quicklisp-client::setup-file-info :superclass quicklisp-client::client-file-info)

(:mop-direct quicklisp-client::asdf-file-info :superclass quicklisp-client::client-file-info)
(:mop-direct quicklisp-client::asdf-file-info :default-initargs
 ((:plist-key :asdf #<compiled-function clos::constant-initfunction>) (:name "asdf.lisp" #<compiled-function clos::constant-initfunction>)))
(:mop-direct quicklisp-client::asdf-file-info :package-name "QUICKLISP-CLIENT")
(:mop-direct quicklisp-client::asdf-file-info :precedance (quicklisp-client::client-file-info common-lisp:standard-object common-lisp:t))
(:mop-direct quicklisp-client::asdf-file-info :classof clos:standard-class)
(:mop-direct quicklisp-client::asdf-file-info :typeof clos:standard-class)
(:mop-direct quicklisp-client::asdf-file-info :superclass quicklisp-client::client-file-info)


(:mop-direct quicklisp-client::client-info :superclass common-lisp:standard-object)
(:mop-direct quicklisp-client::client-info :package-name "QUICKLISP-CLIENT")
(:mop-direct quicklisp-client::client-info :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct quicklisp-client::client-info :classof clos:standard-class)
(:mop-direct quicklisp-client::client-info :typeof clos:standard-class)
(:mop-direct quicklisp-client::client-info :superclass common-lisp:standard-object)
(:mop-direct quicklisp-client::client-info :slot
 ((:name quicklisp-client::setup-info) (:ordinal 1) (:initargs (:setup-info)) (:readers (quicklisp-client::setup-info))))
(:mop-direct quicklisp-client::client-info :slot
 ((:name quicklisp-client::asdf-info) (:ordinal 2) (:initargs (:asdf-info)) (:readers (quicklisp-client::asdf-info))))
(:mop-direct quicklisp-client::client-info :slot
 ((:name quicklisp-client::client-tar-info) (:ordinal 3) (:initargs (:client-tar-info)) (:readers (quicklisp-client::client-tar-info))))
(:mop-direct quicklisp-client::client-info :slot
 ((:name quicklisp-client::canonical-client-info-url) (:ordinal 4) (:initargs (:canonical-client-info-url))
  (:readers (quicklisp-client::canonical-client-info-url))))
(:mop-direct quicklisp-client::client-info :slot ((:name ql-dist:version) (:ordinal 5) (:initargs (:version)) (:readers (ql-dist:version))))
(:mop-direct quicklisp-client::client-info :slot
 ((:name ql-dist:subscription-url) (:ordinal 6) (:initargs (:subscription-url)) (:readers (ql-dist:subscription-url))))
(:mop-direct quicklisp-client::client-info :slot
 ((:name quicklisp-client::plist) (:ordinal 7) (:initargs (:plist)) (:readers (quicklisp-client::plist))))
(:mop-direct quicklisp-client::client-info :slot
 ((:name quicklisp-client::source-file) (:ordinal 8) (:initargs (:source-file)) (:readers (quicklisp-client::source-file))))

(:mop-direct ql-bundle:bundle :superclass common-lisp:standard-object)
(:mop-direct ql-bundle:bundle :default-initargs
 ((:requested-systems common-lisp:nil #<compiled-function clos::constant-initfunction>)
  (:creation-time (ql-bundle::iso8601-time-stamp) #<compiled-function ql-bundle::default-creation-time>)
  (:release-table (common-lisp:make-hash-table :test 'common-lisp:equalp) #<compiled-function ql-bundle::default-release-table>)
  (:system-table (common-lisp:make-hash-table :test 'common-lisp:equalp) #<compiled-function ql-bundle::default-system-table>)))
(:mop-direct ql-bundle:bundle :package-name "QL-BUNDLE")
(:mop-direct ql-bundle:bundle :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct ql-bundle:bundle :classof clos:standard-class)
(:mop-direct ql-bundle:bundle :typeof clos:standard-class)
(:mop-direct ql-bundle:bundle :superclass common-lisp:standard-object)
(:mop-direct ql-bundle:bundle :slot
 ((:name ql-bundle:requested-systems) (:ordinal 1) (:initargs (:requested-systems)) (:readers (ql-bundle:requested-systems))))
(:mop-direct ql-bundle:bundle :slot
 ((:name ql-bundle::creation-time) (:ordinal 2) (:initargs (:creation-time)) (:readers (ql-bundle::creation-time))))
(:mop-direct ql-bundle:bundle :slot
 ((:name ql-bundle::release-table) (:ordinal 3) (:initargs (:release-table)) (:readers (ql-bundle::release-table))))
(:mop-direct ql-bundle:bundle :slot
 ((:name ql-bundle::system-table) (:ordinal 4) (:initargs (:system-table)) (:readers (ql-bundle::system-table))))

(:mop-direct uiop/launch-program::process-info :superclass common-lisp:standard-object)
(:mop-direct uiop/launch-program::process-info :package-name "UIOP/LAUNCH-PROGRAM")
(:mop-direct uiop/launch-program::process-info :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct uiop/launch-program::process-info :classof clos:standard-class)
(:mop-direct uiop/launch-program::process-info :typeof clos:standard-class)
(:mop-direct uiop/launch-program::process-info :superclass common-lisp:standard-object)
(:mop-direct uiop/launch-program::process-info :slot ((:name uiop/launch-program::process) (:ordinal 1)))
(:mop-direct uiop/launch-program::process-info :slot ((:name uiop/launch-program::input-stream) (:ordinal 2)))
(:mop-direct uiop/launch-program::process-info :slot ((:name uiop/launch-program::output-stream) (:ordinal 3)))
(:mop-direct uiop/launch-program::process-info :slot ((:name uiop/launch-program::bidir-stream) (:ordinal 4)))
(:mop-direct uiop/launch-program::process-info :slot ((:name uiop/launch-program::error-output-stream) (:ordinal 5)))
(:mop-direct uiop/launch-program::process-info :slot ((:name uiop/launch-program::exit-code) (:ordinal 6)))
(:mop-direct uiop/launch-program::process-info :slot ((:name uiop/launch-program::signal-code) (:ordinal 7)))
(:mop-direct uiop/launch-program::process-info :prototype #<uiop/launch-program::process-info #x000335AD47B8>)
(:mop-direct asdf/session:session :superclass common-lisp:standard-object)
(:mop-direct asdf/session:session :package-name "ASDF/SESSION")
(:mop-direct asdf/session:session :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/session:session :classof clos:standard-class)
(:mop-direct asdf/session:session :typeof clos:standard-class)
(:mop-direct asdf/session:session :superclass common-lisp:standard-object)
(:mop-direct asdf/session:session :slot
 ((:name asdf/session::ancestor) (:ordinal 1) (:initargs (:ancestor)) (:readers (asdf/session::session-ancestor))))
(:mop-direct asdf/session:session :slot
 ((:name asdf/session:session-cache) (:ordinal 2) (:initform (common-lisp:make-hash-table :test 'common-lisp:equal))
  (:initargs (:session-cache)) (:readers (asdf/session:session-cache))))
(:mop-direct asdf/session:session :slot
 ((:name asdf/session:operate-level) (:ordinal 3) (:initform 0) (:initargs (:operate-level)) (:readers (asdf/session::session-operate-level))
  (:writers ((common-lisp:setf asdf/session::session-operate-level)))))
(:mop-direct asdf/session:session :slot
 ((:name asdf/session:asdf-upgraded-p) (:ordinal 4) (:initargs (:asdf-upgraded-p)) (:readers (asdf/session:asdf-upgraded-p))
  (:writers ((common-lisp:setf asdf/session:asdf-upgraded-p)))))
(:mop-direct asdf/session:session :slot
 ((:name asdf/session:forcing) (:ordinal 5) (:initargs (:forcing)) (:readers (asdf/session:forcing))
  (:writers ((common-lisp:setf asdf/session:forcing)))))
(:mop-direct asdf/session:session :slot
 ((:name asdf/session:visited-actions) (:ordinal 6) (:initform (common-lisp:make-hash-table :test 'common-lisp:equal))
  (:readers (asdf/session:visited-actions)) (:writers ((common-lisp:setf asdf/session:visited-actions)))))
(:mop-direct asdf/session:session :slot
 ((:name asdf/session:visiting-action-set) (:ordinal 7) (:initform (common-lisp:make-hash-table :test 'common-lisp:equal))
  (:readers (asdf/session:visiting-action-set)) (:writers ((common-lisp:setf asdf/session:visiting-action-set)))))
(:mop-direct asdf/session:session :slot
 ((:name asdf/session:visiting-action-list) (:ordinal 8) (:readers (asdf/session:visiting-action-list))
  (:writers ((common-lisp:setf asdf/session:visiting-action-list)))))
(:mop-direct asdf/session:session :slot
 ((:name asdf/session:total-action-count) (:ordinal 9) (:initform 0) (:readers (asdf/session:total-action-count))
  (:writers ((common-lisp:setf asdf/session:total-action-count)))))
(:mop-direct asdf/session:session :slot
 ((:name asdf/session:planned-action-count) (:ordinal 10) (:initform 0) (:readers (asdf/session:planned-action-count))
  (:writers ((common-lisp:setf asdf/session:planned-action-count)))))
(:mop-direct asdf/session:session :slot
 ((:name asdf/session:planned-output-action-count) (:ordinal 11) (:initform 0) (:readers (asdf/session:planned-output-action-count))
  (:writers ((common-lisp:setf asdf/session:planned-output-action-count)))))
(:mop-direct asdf/session:session :prototype #<asdf/session:session #x000335AF7BC0>)
(:mop-direct asdf/component:component :superclass common-lisp:standard-object)
(:mop-direct asdf/component:parent-component :superclass asdf/component:component)
(:mop-direct asdf/component:child-component :superclass asdf/component:component)
(:mop-direct asdf/component:component :package-name "ASDF/COMPONENT")
(:mop-direct asdf/component:component :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/component:component :classof clos:standard-class)
(:mop-direct asdf/component:component :typeof clos:standard-class)
(:mop-direct asdf/component:component :superclass common-lisp:standard-object)
(:mop-direct asdf/component:component :slot
 ((:name asdf/component:name) (:ordinal 1) (:type common-lisp:string) (:initargs (:name)) (:readers (asdf/component:component-name))
  (:writers ((common-lisp:setf asdf/component:component-name)))))
(:mop-direct asdf/component:component :slot
 ((:name asdf/component:version) (:ordinal 2) (:initargs (:version)) (:readers (asdf/component:component-version))
  (:writers ((common-lisp:setf asdf/component:component-version)))))
(:mop-direct asdf/component:component :slot
 ((:name asdf/component:description) (:ordinal 3) (:initargs (:description)) (:readers (asdf/component:component-description))
  (:writers ((common-lisp:setf asdf/component:component-description)))))
(:mop-direct asdf/component:component :slot
 ((:name asdf/component:long-description) (:ordinal 4) (:initargs (:long-description)) (:readers (asdf/component:component-long-description))
  (:writers ((common-lisp:setf asdf/component:component-long-description)))))
(:mop-direct asdf/component:component :slot
 ((:name asdf/component:sideway-dependencies) (:ordinal 5) (:readers (asdf/component:component-sideway-dependencies))
  (:writers ((common-lisp:setf asdf/component:component-sideway-dependencies)))))
(:mop-direct asdf/component:component :slot
 ((:name asdf/component:if-feature) (:ordinal 6) (:initargs (:if-feature)) (:readers (asdf/component:component-if-feature))
  (:writers ((common-lisp:setf asdf/component:component-if-feature)))))
(:mop-direct asdf/component:component :slot
 ((:name asdf/component:in-order-to) (:ordinal 7) (:initargs (:in-order-to)) (:readers (asdf/component:component-in-order-to))
  (:writers ((common-lisp:setf asdf/component:component-in-order-to)))))
(:mop-direct asdf/component:component :slot
 ((:name asdf/component:inline-methods) (:ordinal 8) (:readers (asdf/component:component-inline-methods))
  (:writers ((common-lisp:setf asdf/component:component-inline-methods)))))
(:mop-direct asdf/component:component :slot ((:name asdf/component:relative-pathname) (:ordinal 9) (:initargs (:pathname))))
(:mop-direct asdf/component:component :slot ((:name asdf/component:absolute-pathname) (:ordinal 10)))
(:mop-direct asdf/component:component :slot
 ((:name asdf/component:operation-times) (:ordinal 11) (:initform (common-lisp:make-hash-table))
  (:readers (asdf/component:component-operation-times)) (:writers ((common-lisp:setf asdf/component:component-operation-times)))))
(:mop-direct asdf/component:component :slot ((:name asdf/component:around-compile) (:ordinal 12) (:initargs (:around-compile))))
(:mop-direct asdf/component:component :slot
 ((:name asdf/component:properties) (:ordinal 13) (:initargs (:properties)) (:readers (asdf/component:component-properties))
  (:writers ((common-lisp:setf asdf/component:component-properties)))))
(:mop-direct asdf/component:component :slot
 ((:name asdf/component:%encoding) (:ordinal 14) (:initargs (:encoding)) (:readers (asdf/component::%component-encoding))
  (:writers ((common-lisp:setf asdf/component::%component-encoding)))))
(:mop-direct asdf/component:component :slot
 ((:name asdf/component:parent) (:ordinal 15) (:initargs (:parent)) (:readers (asdf/component:component-parent))))
(:mop-direct asdf/component:component :slot
 ((:name asdf/component::build-operation) (:ordinal 16) (:initargs (:build-operation)) (:readers (asdf/component:component-build-operation))))
(:mop-direct asdf/component:component :slot
 ((:name asdf/component::additional-input-files) (:ordinal 17) (:readers (asdf/component::%additional-input-files))
  (:writers ((common-lisp:setf asdf/component::%additional-input-files)))))
(:mop-direct asdf/component:parent-component :superclass asdf/component:component)
(:mop-direct asdf/component:module :superclass asdf/component:parent-component)
(:mop-direct asdf/component:parent-component :package-name "ASDF/COMPONENT")
(:mop-direct asdf/component:parent-component :precedance (asdf/component:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/component:parent-component :classof clos:standard-class)
(:mop-direct asdf/component:parent-component :typeof clos:standard-class)
(:mop-direct asdf/component:parent-component :superclass asdf/component:component)
(:mop-direct asdf/component:parent-component :slot
 ((:name asdf/component:children) (:ordinal 1) (:initargs (:components))
  (:readers (asdf/component:module-components asdf/component:component-children))
  (:writers ((common-lisp:setf asdf/component:component-children)))))
(:mop-direct asdf/component:parent-component :slot
 ((:name asdf/component:children-by-name) (:ordinal 2)
  (:readers (asdf/component::module-components-by-name asdf/component:component-children-by-name))
  (:writers ((common-lisp:setf asdf/component:component-children-by-name)))))
(:mop-direct asdf/component:parent-component :slot
 ((:name asdf/component:default-component-class) (:ordinal 3) (:initargs (:default-component-class))
  (:readers (asdf/component:module-default-component-class)) (:writers ((common-lisp:setf asdf/component:module-default-component-class)))))
(:mop-direct asdf/component:module :superclass asdf/component:child-component)
(:mop-direct asdf/component:module :superclass asdf/component:parent-component)
(:mop-direct asdf/system:system :superclass asdf/component:module)
(:mop-direct asdf/component:module :package-name "ASDF/COMPONENT")
(:mop-direct asdf/component:module :precedance
 (asdf/component:child-component asdf/component:parent-component asdf/component:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/component:module :classof clos:standard-class)
(:mop-direct asdf/component:module :typeof clos:standard-class)
(:mop-direct asdf/component:module :superclass asdf/component:parent-component)
(:mop-direct asdf/component:module :slot ((:name asdf/component:components) (:ordinal 1)))
(:mop-direct asdf/system:system :superclass asdf/component:module)
(:mop-direct asdf/system:system :superclass asdf/system:proto-system)
(:mop-direct asdf/package-inferred-system:package-inferred-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:prebuilt-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:precompiled-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:program-system :superclass asdf/system:system)
(:mop-direct asdf/operate:require-system :superclass asdf/system:system)
(:mop-direct asdf/system:undefined-system :superclass asdf/system:system)
(:mop-direct asdf/system:system :package-name "ASDF/SYSTEM")
(:mop-direct asdf/system:system :precedance
 (asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component asdf/system:proto-system
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/system:system :classof clos:standard-class)
(:mop-direct asdf/system:system :typeof clos:standard-class)
(:mop-direct asdf/system:system :superclass asdf/component:module)
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:description) (:ordinal 1) (:readers (asdf/system:system-description))
  (:writers ((common-lisp:setf asdf/system:system-description)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:long-description) (:ordinal 2) (:readers (asdf/system:system-long-description))
  (:writers ((common-lisp:setf asdf/system:system-long-description)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:author) (:ordinal 3) (:initargs (:author)) (:readers (asdf/system:system-author))
  (:writers ((common-lisp:setf asdf/system:system-author)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:maintainer) (:ordinal 4) (:initargs (:maintainer)) (:readers (asdf/system:system-maintainer))
  (:writers ((common-lisp:setf asdf/system:system-maintainer)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:licence) (:ordinal 5) (:initargs (:licence :license)) (:readers (asdf/system:system-licence asdf/system:system-license))
  (:writers ((common-lisp:setf asdf/system:system-licence) (common-lisp:setf asdf/system:system-license)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:homepage) (:ordinal 6) (:initargs (:homepage)) (:readers (asdf/system:system-homepage))
  (:writers ((common-lisp:setf asdf/system:system-homepage)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:bug-tracker) (:ordinal 7) (:initargs (:bug-tracker)) (:readers (asdf/system:system-bug-tracker))
  (:writers ((common-lisp:setf asdf/system:system-bug-tracker)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:mailto) (:ordinal 8) (:initargs (:mailto)) (:readers (asdf/system:system-mailto))
  (:writers ((common-lisp:setf asdf/system:system-mailto)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:long-name) (:ordinal 9) (:initargs (:long-name)) (:readers (asdf/system:system-long-name))
  (:writers ((common-lisp:setf asdf/system:system-long-name)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:source-control) (:ordinal 10) (:initargs (:source-control)) (:readers (asdf/system:system-source-control))
  (:writers ((common-lisp:setf asdf/system:system-source-control)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:builtin-system-p) (:ordinal 11) (:initargs (:builtin-system-p)) (:readers (asdf/system:builtin-system-p))
  (:writers ((common-lisp:setf asdf/system:builtin-system-p)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:build-pathname) (:ordinal 12) (:initargs (:build-pathname)) (:readers (asdf/system:component-build-pathname))
  (:writers ((common-lisp:setf asdf/system:component-build-pathname)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:entry-point) (:ordinal 13) (:initargs (:entry-point)) (:readers (asdf/system:component-entry-point))
  (:writers ((common-lisp:setf asdf/system:component-entry-point)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:source-file) (:ordinal 14) (:initargs (:source-file)) (:readers (asdf/system:system-source-file))
  (:writers ((common-lisp:setf asdf/system:system-source-file)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:defsystem-depends-on) (:ordinal 15) (:initargs (:defsystem-depends-on))
  (:readers (asdf/system:system-defsystem-depends-on))))
(:mop-direct asdf/system:system :slot ((:name asdf/system::depends-on) (:ordinal 16) (:readers (asdf/system:system-depends-on))))
(:mop-direct asdf/system:system :slot ((:name asdf/system::weakly-depends-on) (:ordinal 17) (:readers (asdf/system:system-weakly-depends-on))))
(:mop-direct asdf/package-inferred-system:package-inferred-system :superclass asdf/system:system)
(:mop-direct asdf/package-inferred-system:package-system :superclass asdf/package-inferred-system:package-inferred-system)
(:mop-direct asdf/package-inferred-system:package-inferred-system :package-name "ASDF/PACKAGE-INFERRED-SYSTEM")
(:mop-direct asdf/package-inferred-system:package-inferred-system :precedance
 (asdf/system:system asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component
  asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/package-inferred-system:package-inferred-system :classof clos:standard-class)
(:mop-direct asdf/package-inferred-system:package-inferred-system :typeof clos:standard-class)
(:mop-direct asdf/package-inferred-system:package-inferred-system :superclass asdf/system:system)
(:mop-direct asdf/package-inferred-system:package-system :superclass asdf/package-inferred-system:package-inferred-system)
(:mop-direct asdf/package-inferred-system:package-system :package-name "ASDF/PACKAGE-INFERRED-SYSTEM")
(:mop-direct asdf/package-inferred-system:package-system :precedance
 (asdf/package-inferred-system:package-inferred-system asdf/system:system asdf/component:module asdf/component:child-component
  asdf/component:parent-component asdf/component:component asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/package-inferred-system:package-system :classof clos:standard-class)
(:mop-direct asdf/package-inferred-system:package-system :typeof clos:standard-class)
(:mop-direct asdf/package-inferred-system:package-system :superclass asdf/package-inferred-system:package-inferred-system)


(:mop-direct asdf/bundle:prebuilt-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:prebuilt-system :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:prebuilt-system :precedance
 (asdf/system:system asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component
  asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:prebuilt-system :classof clos:standard-class)
(:mop-direct asdf/bundle:prebuilt-system :typeof clos:standard-class)
(:mop-direct asdf/bundle:prebuilt-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:prebuilt-system :slot
 ((:name asdf/system:build-pathname) (:ordinal 1) (:initargs (:static-library :lib)) (:readers (asdf/bundle::prebuilt-system-static-library))
  (:writers ((common-lisp:setf asdf/bundle::prebuilt-system-static-library)))))

(:mop-direct asdf/bundle:precompiled-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:precompiled-system :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:precompiled-system :precedance
 (asdf/system:system asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component
  asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:precompiled-system :classof clos:standard-class)
(:mop-direct asdf/bundle:precompiled-system :typeof clos:standard-class)
(:mop-direct asdf/bundle:precompiled-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:precompiled-system :slot ((:name asdf/system:build-pathname) (:ordinal 1) (:initargs (:fasb :fasl))))

(:mop-direct asdf/bundle:program-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:program-system :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:program-system :precedance
 (asdf/system:system asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component
  asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:program-system :classof clos:standard-class)
(:mop-direct asdf/bundle:program-system :typeof clos:standard-class)
(:mop-direct asdf/bundle:program-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle:prologue-code) (:ordinal 1) (:initargs (:prologue-code)) (:readers (asdf/bundle:prologue-code))))
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle:epilogue-code) (:ordinal 2) (:initargs (:epilogue-code)) (:readers (asdf/bundle:epilogue-code))))
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle::no-uiop) (:ordinal 3) (:initargs (:no-uiop)) (:readers (asdf/bundle::no-uiop))))
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle::prefix-lisp-object-files) (:ordinal 4) (:initargs (:prefix-lisp-object-files))
  (:readers (asdf/bundle::prefix-lisp-object-files)) (:writers ((common-lisp:setf asdf/bundle::prefix-lisp-object-files)))))
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle::postfix-lisp-object-files) (:ordinal 5) (:initargs (:postfix-lisp-object-files))
  (:readers (asdf/bundle::postfix-lisp-object-files)) (:writers ((common-lisp:setf asdf/bundle::postfix-lisp-object-files)))))
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle::extra-object-files) (:ordinal 6) (:initargs (:extra-object-files)) (:readers (asdf/bundle::extra-object-files))
  (:writers ((common-lisp:setf asdf/bundle::extra-object-files)))))
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle::extra-build-args) (:ordinal 7) (:initargs (:extra-build-args)) (:readers (asdf/bundle::extra-build-args))
  (:writers ((common-lisp:setf asdf/bundle::extra-build-args)))))

(:mop-direct asdf/operate:require-system :superclass asdf/system:system)
(:mop-direct asdf/operate:require-system :package-name "ASDF/OPERATE")
(:mop-direct asdf/operate:require-system :precedance
 (asdf/system:system asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component
  asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/operate:require-system :classof clos:standard-class)
(:mop-direct asdf/operate:require-system :typeof clos:standard-class)
(:mop-direct asdf/operate:require-system :superclass asdf/system:system)
(:mop-direct asdf/operate:require-system :slot
 ((:name asdf/component:module) (:ordinal 1) (:initargs (:module)) (:readers (asdf/operate::required-module))
  (:writers ((common-lisp:setf asdf/operate::required-module)))))

(:mop-direct asdf/system:undefined-system :superclass asdf/system:system)
(:mop-direct asdf/system:undefined-system :package-name "ASDF/SYSTEM")
(:mop-direct asdf/system:undefined-system :precedance
 (asdf/system:system asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component
  asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/system:undefined-system :classof clos:standard-class)
(:mop-direct asdf/system:undefined-system :typeof clos:standard-class)
(:mop-direct asdf/system:undefined-system :superclass asdf/system:system)




(:mop-direct asdf/component:child-component :superclass asdf/component:component)
(:mop-direct asdf/component:module :superclass asdf/component:child-component)
(:mop-direct asdf/component:file-component :superclass asdf/component:child-component)
(:mop-direct asdf/component:child-component :package-name "ASDF/COMPONENT")
(:mop-direct asdf/component:child-component :precedance (asdf/component:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/component:child-component :classof clos:standard-class)
(:mop-direct asdf/component:child-component :typeof clos:standard-class)
(:mop-direct asdf/component:child-component :superclass asdf/component:component)
(:mop-direct asdf/component:module :superclass asdf/component:child-component)
(:mop-direct asdf/component:module :superclass asdf/component:parent-component)
(:mop-direct asdf/system:system :superclass asdf/component:module)
(:mop-direct asdf/component:module :package-name "ASDF/COMPONENT")
(:mop-direct asdf/component:module :precedance
 (asdf/component:child-component asdf/component:parent-component asdf/component:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/component:module :classof clos:standard-class)
(:mop-direct asdf/component:module :typeof clos:standard-class)
(:mop-direct asdf/component:module :superclass asdf/component:child-component)
(:mop-direct asdf/component:module :slot ((:name asdf/component:components) (:ordinal 1)))
(:mop-direct asdf/system:system :superclass asdf/component:module)
(:mop-direct asdf/system:system :superclass asdf/system:proto-system)
(:mop-direct asdf/package-inferred-system:package-inferred-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:prebuilt-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:precompiled-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:program-system :superclass asdf/system:system)
(:mop-direct asdf/operate:require-system :superclass asdf/system:system)
(:mop-direct asdf/system:undefined-system :superclass asdf/system:system)
(:mop-direct asdf/system:system :package-name "ASDF/SYSTEM")
(:mop-direct asdf/system:system :precedance
 (asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component asdf/system:proto-system
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/system:system :classof clos:standard-class)
(:mop-direct asdf/system:system :typeof clos:standard-class)
(:mop-direct asdf/system:system :superclass asdf/component:module)
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:description) (:ordinal 1) (:readers (asdf/system:system-description))
  (:writers ((common-lisp:setf asdf/system:system-description)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:long-description) (:ordinal 2) (:readers (asdf/system:system-long-description))
  (:writers ((common-lisp:setf asdf/system:system-long-description)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:author) (:ordinal 3) (:initargs (:author)) (:readers (asdf/system:system-author))
  (:writers ((common-lisp:setf asdf/system:system-author)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:maintainer) (:ordinal 4) (:initargs (:maintainer)) (:readers (asdf/system:system-maintainer))
  (:writers ((common-lisp:setf asdf/system:system-maintainer)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:licence) (:ordinal 5) (:initargs (:licence :license)) (:readers (asdf/system:system-licence asdf/system:system-license))
  (:writers ((common-lisp:setf asdf/system:system-licence) (common-lisp:setf asdf/system:system-license)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:homepage) (:ordinal 6) (:initargs (:homepage)) (:readers (asdf/system:system-homepage))
  (:writers ((common-lisp:setf asdf/system:system-homepage)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:bug-tracker) (:ordinal 7) (:initargs (:bug-tracker)) (:readers (asdf/system:system-bug-tracker))
  (:writers ((common-lisp:setf asdf/system:system-bug-tracker)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:mailto) (:ordinal 8) (:initargs (:mailto)) (:readers (asdf/system:system-mailto))
  (:writers ((common-lisp:setf asdf/system:system-mailto)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:long-name) (:ordinal 9) (:initargs (:long-name)) (:readers (asdf/system:system-long-name))
  (:writers ((common-lisp:setf asdf/system:system-long-name)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:source-control) (:ordinal 10) (:initargs (:source-control)) (:readers (asdf/system:system-source-control))
  (:writers ((common-lisp:setf asdf/system:system-source-control)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:builtin-system-p) (:ordinal 11) (:initargs (:builtin-system-p)) (:readers (asdf/system:builtin-system-p))
  (:writers ((common-lisp:setf asdf/system:builtin-system-p)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:build-pathname) (:ordinal 12) (:initargs (:build-pathname)) (:readers (asdf/system:component-build-pathname))
  (:writers ((common-lisp:setf asdf/system:component-build-pathname)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:entry-point) (:ordinal 13) (:initargs (:entry-point)) (:readers (asdf/system:component-entry-point))
  (:writers ((common-lisp:setf asdf/system:component-entry-point)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:source-file) (:ordinal 14) (:initargs (:source-file)) (:readers (asdf/system:system-source-file))
  (:writers ((common-lisp:setf asdf/system:system-source-file)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:defsystem-depends-on) (:ordinal 15) (:initargs (:defsystem-depends-on))
  (:readers (asdf/system:system-defsystem-depends-on))))
(:mop-direct asdf/system:system :slot ((:name asdf/system::depends-on) (:ordinal 16) (:readers (asdf/system:system-depends-on))))
(:mop-direct asdf/system:system :slot ((:name asdf/system::weakly-depends-on) (:ordinal 17) (:readers (asdf/system:system-weakly-depends-on))))
(:mop-direct asdf/package-inferred-system:package-inferred-system :superclass asdf/system:system)
(:mop-direct asdf/package-inferred-system:package-system :superclass asdf/package-inferred-system:package-inferred-system)
(:mop-direct asdf/package-inferred-system:package-inferred-system :package-name "ASDF/PACKAGE-INFERRED-SYSTEM")
(:mop-direct asdf/package-inferred-system:package-inferred-system :precedance
 (asdf/system:system asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component
  asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/package-inferred-system:package-inferred-system :classof clos:standard-class)
(:mop-direct asdf/package-inferred-system:package-inferred-system :typeof clos:standard-class)
(:mop-direct asdf/package-inferred-system:package-inferred-system :superclass asdf/system:system)
(:mop-direct asdf/package-inferred-system:package-system :superclass asdf/package-inferred-system:package-inferred-system)
(:mop-direct asdf/package-inferred-system:package-system :package-name "ASDF/PACKAGE-INFERRED-SYSTEM")
(:mop-direct asdf/package-inferred-system:package-system :precedance
 (asdf/package-inferred-system:package-inferred-system asdf/system:system asdf/component:module asdf/component:child-component
  asdf/component:parent-component asdf/component:component asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/package-inferred-system:package-system :classof clos:standard-class)
(:mop-direct asdf/package-inferred-system:package-system :typeof clos:standard-class)
(:mop-direct asdf/package-inferred-system:package-system :superclass asdf/package-inferred-system:package-inferred-system)


(:mop-direct asdf/bundle:prebuilt-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:prebuilt-system :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:prebuilt-system :precedance
 (asdf/system:system asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component
  asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:prebuilt-system :classof clos:standard-class)
(:mop-direct asdf/bundle:prebuilt-system :typeof clos:standard-class)
(:mop-direct asdf/bundle:prebuilt-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:prebuilt-system :slot
 ((:name asdf/system:build-pathname) (:ordinal 1) (:initargs (:static-library :lib)) (:readers (asdf/bundle::prebuilt-system-static-library))
  (:writers ((common-lisp:setf asdf/bundle::prebuilt-system-static-library)))))

(:mop-direct asdf/bundle:precompiled-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:precompiled-system :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:precompiled-system :precedance
 (asdf/system:system asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component
  asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:precompiled-system :classof clos:standard-class)
(:mop-direct asdf/bundle:precompiled-system :typeof clos:standard-class)
(:mop-direct asdf/bundle:precompiled-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:precompiled-system :slot ((:name asdf/system:build-pathname) (:ordinal 1) (:initargs (:fasb :fasl))))

(:mop-direct asdf/bundle:program-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:program-system :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:program-system :precedance
 (asdf/system:system asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component
  asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:program-system :classof clos:standard-class)
(:mop-direct asdf/bundle:program-system :typeof clos:standard-class)
(:mop-direct asdf/bundle:program-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle:prologue-code) (:ordinal 1) (:initargs (:prologue-code)) (:readers (asdf/bundle:prologue-code))))
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle:epilogue-code) (:ordinal 2) (:initargs (:epilogue-code)) (:readers (asdf/bundle:epilogue-code))))
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle::no-uiop) (:ordinal 3) (:initargs (:no-uiop)) (:readers (asdf/bundle::no-uiop))))
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle::prefix-lisp-object-files) (:ordinal 4) (:initargs (:prefix-lisp-object-files))
  (:readers (asdf/bundle::prefix-lisp-object-files)) (:writers ((common-lisp:setf asdf/bundle::prefix-lisp-object-files)))))
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle::postfix-lisp-object-files) (:ordinal 5) (:initargs (:postfix-lisp-object-files))
  (:readers (asdf/bundle::postfix-lisp-object-files)) (:writers ((common-lisp:setf asdf/bundle::postfix-lisp-object-files)))))
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle::extra-object-files) (:ordinal 6) (:initargs (:extra-object-files)) (:readers (asdf/bundle::extra-object-files))
  (:writers ((common-lisp:setf asdf/bundle::extra-object-files)))))
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle::extra-build-args) (:ordinal 7) (:initargs (:extra-build-args)) (:readers (asdf/bundle::extra-build-args))
  (:writers ((common-lisp:setf asdf/bundle::extra-build-args)))))

(:mop-direct asdf/operate:require-system :superclass asdf/system:system)
(:mop-direct asdf/operate:require-system :package-name "ASDF/OPERATE")
(:mop-direct asdf/operate:require-system :precedance
 (asdf/system:system asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component
  asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/operate:require-system :classof clos:standard-class)
(:mop-direct asdf/operate:require-system :typeof clos:standard-class)
(:mop-direct asdf/operate:require-system :superclass asdf/system:system)
(:mop-direct asdf/operate:require-system :slot
 ((:name asdf/component:module) (:ordinal 1) (:initargs (:module)) (:readers (asdf/operate::required-module))
  (:writers ((common-lisp:setf asdf/operate::required-module)))))

(:mop-direct asdf/system:undefined-system :superclass asdf/system:system)
(:mop-direct asdf/system:undefined-system :package-name "ASDF/SYSTEM")
(:mop-direct asdf/system:undefined-system :precedance
 (asdf/system:system asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component
  asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/system:undefined-system :classof clos:standard-class)
(:mop-direct asdf/system:undefined-system :typeof clos:standard-class)
(:mop-direct asdf/system:undefined-system :superclass asdf/system:system)



(:mop-direct asdf/component:file-component :superclass asdf/component:child-component)
(:mop-direct asdf/bundle:compiled-file :superclass asdf/component:file-component)
(:mop-direct asdf/component:source-file :superclass asdf/component:file-component)
(:mop-direct asdf/component:file-component :package-name "ASDF/COMPONENT")
(:mop-direct asdf/component:file-component :precedance
 (asdf/component:child-component asdf/component:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/component:file-component :classof clos:standard-class)
(:mop-direct asdf/component:file-component :typeof clos:standard-class)
(:mop-direct asdf/component:file-component :superclass asdf/component:child-component)
(:mop-direct asdf/component:file-component :slot
 ((:name common-lisp:type) (:ordinal 1) (:initargs (:type)) (:readers (asdf/component:file-type))
  (:writers ((common-lisp:setf asdf/component:file-type)))))
(:mop-direct asdf/bundle:compiled-file :superclass asdf/component:file-component)
(:mop-direct asdf/bundle:compiled-file :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:compiled-file :precedance
 (asdf/component:file-component asdf/component:child-component asdf/component:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:compiled-file :classof clos:standard-class)
(:mop-direct asdf/bundle:compiled-file :typeof clos:standard-class)
(:mop-direct asdf/bundle:compiled-file :superclass asdf/component:file-component)
(:mop-direct asdf/bundle:compiled-file :slot ((:name common-lisp:type) (:ordinal 1) (:initform (uiop/lisp-build:compile-file-type))))

(:mop-direct asdf/component:source-file :superclass asdf/component:file-component)
(:mop-direct asdf/lisp-action:cl-source-file :superclass asdf/component:source-file)
(:mop-direct asdf/component:static-file :superclass asdf/component:source-file)
(:mop-direct asdf/component:java-source-file :superclass asdf/component:source-file)
(:mop-direct asdf/component:c-source-file :superclass asdf/component:source-file)
(:mop-direct asdf/component:source-file :package-name "ASDF/COMPONENT")
(:mop-direct asdf/component:source-file :precedance
 (asdf/component:file-component asdf/component:child-component asdf/component:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/component:source-file :classof clos:standard-class)
(:mop-direct asdf/component:source-file :typeof clos:standard-class)
(:mop-direct asdf/component:source-file :superclass asdf/component:file-component)
(:mop-direct asdf/component:source-file :slot
 ((:name common-lisp:type) (:ordinal 1) (:readers (asdf/component:source-file-explicit-type))
  (:writers ((common-lisp:setf asdf/component:source-file-explicit-type)))))
(:mop-direct asdf/lisp-action:cl-source-file :superclass asdf/component:source-file)
(:mop-direct asdf/lisp-action:cl-source-file.lsp :superclass asdf/lisp-action:cl-source-file)
(:mop-direct asdf/lisp-action:cl-source-file.cl :superclass asdf/lisp-action:cl-source-file)
(:mop-direct asdf/lisp-action:cl-source-file :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:cl-source-file :precedance
 (asdf/component:source-file asdf/component:file-component asdf/component:child-component asdf/component:component common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf/lisp-action:cl-source-file :classof clos:standard-class)
(:mop-direct asdf/lisp-action:cl-source-file :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:cl-source-file :superclass asdf/component:source-file)
(:mop-direct asdf/lisp-action:cl-source-file :slot ((:name common-lisp:type) (:ordinal 1) (:initform "lisp")))
(:mop-direct asdf/lisp-action:cl-source-file.lsp :superclass asdf/lisp-action:cl-source-file)
(:mop-direct asdf/lisp-action:cl-source-file.lsp :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:cl-source-file.lsp :precedance
 (asdf/lisp-action:cl-source-file asdf/component:source-file asdf/component:file-component asdf/component:child-component
  asdf/component:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/lisp-action:cl-source-file.lsp :classof clos:standard-class)
(:mop-direct asdf/lisp-action:cl-source-file.lsp :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:cl-source-file.lsp :superclass asdf/lisp-action:cl-source-file)
(:mop-direct asdf/lisp-action:cl-source-file.lsp :slot ((:name common-lisp:type) (:ordinal 1) (:initform "lsp")))

(:mop-direct asdf/lisp-action:cl-source-file.cl :superclass asdf/lisp-action:cl-source-file)
(:mop-direct asdf/lisp-action:cl-source-file.cl :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:cl-source-file.cl :precedance
 (asdf/lisp-action:cl-source-file asdf/component:source-file asdf/component:file-component asdf/component:child-component
  asdf/component:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/lisp-action:cl-source-file.cl :classof clos:standard-class)
(:mop-direct asdf/lisp-action:cl-source-file.cl :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:cl-source-file.cl :superclass asdf/lisp-action:cl-source-file)
(:mop-direct asdf/lisp-action:cl-source-file.cl :slot ((:name common-lisp:type) (:ordinal 1) (:initform "cl")))


(:mop-direct asdf/component:static-file :superclass asdf/component:source-file)
(:mop-direct asdf/component:doc-file :superclass asdf/component:static-file)
(:mop-direct asdf/component:static-file :package-name "ASDF/COMPONENT")
(:mop-direct asdf/component:static-file :precedance
 (asdf/component:source-file asdf/component:file-component asdf/component:child-component asdf/component:component common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf/component:static-file :classof clos:standard-class)
(:mop-direct asdf/component:static-file :typeof clos:standard-class)
(:mop-direct asdf/component:static-file :superclass asdf/component:source-file)
(:mop-direct asdf/component:static-file :slot ((:name common-lisp:type) (:ordinal 1)))
(:mop-direct asdf/component:doc-file :superclass asdf/component:static-file)
(:mop-direct asdf/component:html-file :superclass asdf/component:doc-file)
(:mop-direct asdf/component:doc-file :package-name "ASDF/COMPONENT")
(:mop-direct asdf/component:doc-file :precedance
 (asdf/component:static-file asdf/component:source-file asdf/component:file-component asdf/component:child-component asdf/component:component
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/component:doc-file :classof clos:standard-class)
(:mop-direct asdf/component:doc-file :typeof clos:standard-class)
(:mop-direct asdf/component:doc-file :superclass asdf/component:static-file)
(:mop-direct asdf/component:html-file :superclass asdf/component:doc-file)
(:mop-direct asdf/component:html-file :package-name "ASDF/COMPONENT")
(:mop-direct asdf/component:html-file :precedance
 (asdf/component:doc-file asdf/component:static-file asdf/component:source-file asdf/component:file-component asdf/component:child-component
  asdf/component:component common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/component:html-file :classof clos:standard-class)
(:mop-direct asdf/component:html-file :typeof clos:standard-class)
(:mop-direct asdf/component:html-file :superclass asdf/component:doc-file)
(:mop-direct asdf/component:html-file :slot ((:name common-lisp:type) (:ordinal 1) (:initform "html")))



(:mop-direct asdf/component:java-source-file :superclass asdf/component:source-file)
(:mop-direct asdf/component:java-source-file :package-name "ASDF/COMPONENT")
(:mop-direct asdf/component:java-source-file :precedance
 (asdf/component:source-file asdf/component:file-component asdf/component:child-component asdf/component:component common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf/component:java-source-file :classof clos:standard-class)
(:mop-direct asdf/component:java-source-file :typeof clos:standard-class)
(:mop-direct asdf/component:java-source-file :superclass asdf/component:source-file)
(:mop-direct asdf/component:java-source-file :slot ((:name common-lisp:type) (:ordinal 1) (:initform "java")))

(:mop-direct asdf/component:c-source-file :superclass asdf/component:source-file)
(:mop-direct asdf/component:c-source-file :package-name "ASDF/COMPONENT")
(:mop-direct asdf/component:c-source-file :precedance
 (asdf/component:source-file asdf/component:file-component asdf/component:child-component asdf/component:component common-lisp:standard-object
  common-lisp:t))
(:mop-direct asdf/component:c-source-file :classof clos:standard-class)
(:mop-direct asdf/component:c-source-file :typeof clos:standard-class)
(:mop-direct asdf/component:c-source-file :superclass asdf/component:source-file)
(:mop-direct asdf/component:c-source-file :slot ((:name common-lisp:type) (:ordinal 1) (:initform "c")))





(:mop-direct asdf/operation:operation :superclass common-lisp:standard-object)
(:mop-direct asdf/bundle:monolithic-op :superclass asdf/operation:operation)
(:mop-direct asdf/bundle:bundle-op :superclass asdf/operation:operation)
(:mop-direct asdf/lisp-action:basic-compile-op :superclass asdf/operation:operation)
(:mop-direct asdf/lisp-action:basic-load-op :superclass asdf/operation:operation)
(:mop-direct asdf/action:non-propagating-operation :superclass asdf/operation:operation)
(:mop-direct asdf/action:selfward-operation :superclass asdf/operation:operation)
(:mop-direct asdf/action:sideway-operation :superclass asdf/operation:operation)
(:mop-direct asdf/action:upward-operation :superclass asdf/operation:operation)
(:mop-direct asdf/action:downward-operation :superclass asdf/operation:operation)
(:mop-direct asdf/operation:operation :package-name "ASDF/OPERATION")
(:mop-direct asdf/operation:operation :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/operation:operation :classof clos:standard-class)
(:mop-direct asdf/operation:operation :typeof clos:standard-class)
(:mop-direct asdf/operation:operation :superclass common-lisp:standard-object)
(:mop-direct asdf/bundle:monolithic-op :superclass asdf/operation:operation)
(:mop-direct asdf/bundle:monolithic-bundle-op :superclass asdf/bundle:monolithic-op)
(:mop-direct asdf/bundle:monolithic-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-op :precedance (asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-op :superclass asdf/operation:operation)
(:mop-direct asdf/bundle:monolithic-bundle-op :superclass asdf/bundle:bundle-op)
(:mop-direct asdf/bundle:monolithic-bundle-op :superclass asdf/bundle:monolithic-op)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:image-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-bundle-op :precedance
 (asdf/bundle:bundle-op asdf/bundle:monolithic-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-bundle-op :superclass asdf/bundle:monolithic-op)
(:mop-direct asdf/bundle:monolithic-bundle-op :slot
 ((:name asdf/bundle:prologue-code) (:ordinal 1) (:readers (asdf/bundle:prologue-code))
  (:writers ((common-lisp:setf asdf/bundle:prologue-code)))))
(:mop-direct asdf/bundle:monolithic-bundle-op :slot
 ((:name asdf/bundle:epilogue-code) (:ordinal 2) (:readers (asdf/bundle:epilogue-code))
  (:writers ((common-lisp:setf asdf/bundle:epilogue-code)))))
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/concatenate-source::basic-concatenate-source-op)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :precedance
 (asdf/concatenate-source::basic-concatenate-source-op asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op asdf/bundle:monolithic-op
  asdf/action:non-propagating-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :prototype #<asdf/concatenate-source:monolithic-concatenate-source-op>)
(:mop-direct asdf/bundle:image-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:image-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:program-op :superclass asdf/bundle:image-op)
(:mop-direct asdf/bundle:image-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:image-op :precedance
 (asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op asdf/bundle:monolithic-op asdf/action:selfward-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:image-op :classof clos:standard-class)
(:mop-direct asdf/bundle:image-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:image-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:image-op :slot ((:name asdf/bundle:bundle-type) (:ordinal 1) (:allocation :class) (:initform :image)))
(:mop-direct asdf/bundle:image-op :slot
 ((:name asdf/bundle::gather-operation) (:ordinal 2) (:allocation :class) (:initform 'asdf/bundle:lib-op)))
(:mop-direct asdf/bundle:image-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 3) (:allocation :class) (:initform '(asdf/lisp-action:load-op))))
(:mop-direct asdf/bundle:program-op :superclass asdf/bundle:image-op)
(:mop-direct asdf/bundle:program-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:program-op :precedance
 (asdf/bundle:image-op asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op asdf/bundle:monolithic-op asdf/action:selfward-operation
  asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:program-op :classof clos:standard-class)
(:mop-direct asdf/bundle:program-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:program-op :superclass asdf/bundle:image-op)
(:mop-direct asdf/bundle:program-op :slot ((:name asdf/bundle:bundle-type) (:ordinal 1) (:allocation :class) (:initform :program)))
(:mop-direct asdf/bundle:program-op :prototype #<asdf/bundle:program-op>)
(:mop-direct asdf/bundle:image-op :prototype #<asdf/bundle:image-op>)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:dll-op)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-dll-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-dll-op :precedance
 (asdf/bundle:dll-op asdf/bundle::link-op asdf/bundle::gather-operation asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op
  asdf/bundle:monolithic-op asdf/action:non-propagating-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-dll-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-dll-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-dll-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :object)))
(:mop-direct asdf/bundle:monolithic-dll-op :prototype #<asdf/bundle:monolithic-dll-op>)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:lib-op)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-lib-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-lib-op :precedance
 (asdf/bundle:lib-op asdf/bundle::link-op asdf/bundle::gather-operation asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op
  asdf/bundle:monolithic-op asdf/action:non-propagating-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-lib-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-lib-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-lib-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :object)))
(:mop-direct asdf/bundle:monolithic-lib-op :prototype #<asdf/bundle:monolithic-lib-op>)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :superclass asdf/bundle:load-bundle-op)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-load-bundle-op :precedance
 (asdf/bundle:load-bundle-op asdf/lisp-action:basic-load-op asdf/action:selfward-operation asdf/bundle:monolithic-bundle-op
  asdf/bundle:bundle-op asdf/bundle:monolithic-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-load-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform 'asdf/bundle:monolithic-compile-bundle-op)))
(:mop-direct asdf/bundle:monolithic-load-bundle-op :prototype #<asdf/bundle:monolithic-load-bundle-op>)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:basic-compile-bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :precedance
 (asdf/bundle:basic-compile-bundle-op asdf/bundle:monolithic-bundle-op asdf/bundle::gather-operation asdf/bundle:bundle-op
  asdf/bundle:monolithic-op asdf/lisp-action:basic-compile-op asdf/action:non-propagating-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :prototype #<asdf/bundle:monolithic-compile-bundle-op>)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :superclass asdf/bundle:deliver-asd-op)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :precedance
 (asdf/bundle:deliver-asd-op asdf/lisp-action:basic-compile-op asdf/action:selfward-operation asdf/bundle:monolithic-bundle-op
  asdf/bundle:bundle-op asdf/bundle:monolithic-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform '(asdf/bundle:monolithic-compile-bundle-op))))
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :prototype #<asdf/bundle:monolithic-deliver-asd-op>)
(:mop-direct asdf/bundle:monolithic-bundle-op :prototype #<asdf/bundle:monolithic-bundle-op>)
(:mop-direct asdf/bundle:monolithic-op :prototype #<asdf/bundle:monolithic-op>)
(:mop-direct asdf/bundle:bundle-op :superclass asdf/operation:operation)
(:mop-direct asdf/concatenate-source::basic-concatenate-source-op :superclass asdf/bundle:bundle-op)
(:mop-direct asdf/bundle:basic-compile-bundle-op :superclass asdf/bundle:bundle-op)
(:mop-direct asdf/bundle::gather-operation :superclass asdf/bundle:bundle-op)
(:mop-direct asdf/bundle::link-op :superclass asdf/bundle:bundle-op)
(:mop-direct asdf/bundle:monolithic-bundle-op :superclass asdf/bundle:bundle-op)
(:mop-direct asdf/bundle:bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:bundle-op :precedance (asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:bundle-op :superclass asdf/operation:operation)
(:mop-direct asdf/bundle:bundle-op :slot
 ((:name asdf/bundle:bundle-type) (:ordinal 1) (:allocation :class) (:initform :no-output-file) (:readers (asdf/bundle:bundle-type))))
(:mop-direct asdf/concatenate-source::basic-concatenate-source-op :superclass asdf/bundle:bundle-op)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/concatenate-source::basic-concatenate-source-op)
(:mop-direct asdf/concatenate-source:concatenate-source-op :superclass asdf/concatenate-source::basic-concatenate-source-op)
(:mop-direct asdf/concatenate-source::basic-concatenate-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source::basic-concatenate-source-op :precedance
 (asdf/bundle:bundle-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source::basic-concatenate-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source::basic-concatenate-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source::basic-concatenate-source-op :superclass asdf/bundle:bundle-op)
(:mop-direct asdf/concatenate-source::basic-concatenate-source-op :slot
 ((:name asdf/bundle:bundle-type) (:ordinal 1) (:allocation :class) (:initform "lisp")))
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/concatenate-source::basic-concatenate-source-op)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :precedance
 (asdf/concatenate-source::basic-concatenate-source-op asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op asdf/bundle:monolithic-op
  asdf/action:non-propagating-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/concatenate-source::basic-concatenate-source-op)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :prototype #<asdf/concatenate-source:monolithic-concatenate-source-op>)
(:mop-direct asdf/concatenate-source:concatenate-source-op :superclass asdf/concatenate-source::basic-concatenate-source-op)
(:mop-direct asdf/concatenate-source:concatenate-source-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/concatenate-source:concatenate-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source:concatenate-source-op :precedance
 (asdf/concatenate-source::basic-concatenate-source-op asdf/bundle:bundle-op asdf/action:non-propagating-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source:concatenate-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source:concatenate-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source:concatenate-source-op :superclass asdf/concatenate-source::basic-concatenate-source-op)
(:mop-direct asdf/concatenate-source:concatenate-source-op :prototype #<asdf/concatenate-source:concatenate-source-op>)
(:mop-direct asdf/concatenate-source::basic-concatenate-source-op :prototype #<asdf/concatenate-source::basic-concatenate-source-op>)
(:mop-direct asdf/bundle:basic-compile-bundle-op :superclass asdf/bundle:bundle-op)
(:mop-direct asdf/bundle:basic-compile-bundle-op :superclass asdf/lisp-action:basic-compile-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:basic-compile-bundle-op)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/bundle:basic-compile-bundle-op)
(:mop-direct asdf/bundle:basic-compile-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:basic-compile-bundle-op :precedance
 (asdf/bundle:bundle-op asdf/lisp-action:basic-compile-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:basic-compile-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:basic-compile-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:basic-compile-bundle-op :superclass asdf/bundle:bundle-op)
(:mop-direct asdf/bundle:basic-compile-bundle-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :fasl)))
(:mop-direct asdf/bundle:basic-compile-bundle-op :slot ((:name asdf/bundle:bundle-type) (:ordinal 2) (:allocation :class) (:initform :fasb)))
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:basic-compile-bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :precedance
 (asdf/bundle:basic-compile-bundle-op asdf/bundle:monolithic-bundle-op asdf/bundle::gather-operation asdf/bundle:bundle-op
  asdf/bundle:monolithic-op asdf/lisp-action:basic-compile-op asdf/action:non-propagating-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:basic-compile-bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :prototype #<asdf/bundle:monolithic-compile-bundle-op>)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/bundle:basic-compile-bundle-op)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:compile-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:compile-bundle-op :precedance
 (asdf/bundle:basic-compile-bundle-op asdf/action:selfward-operation asdf/bundle::gather-operation asdf/bundle:bundle-op
  asdf/lisp-action:basic-compile-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:compile-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:compile-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/bundle:basic-compile-bundle-op)
(:mop-direct asdf/bundle:compile-bundle-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform '(asdf/bundle:prepare-bundle-op))))
(:mop-direct asdf/bundle:compile-bundle-op :prototype #<asdf/bundle:compile-bundle-op>)
(:mop-direct asdf/bundle:basic-compile-bundle-op :prototype #<asdf/bundle:basic-compile-bundle-op>)
(:mop-direct asdf/bundle::gather-operation :superclass asdf/bundle:bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:dll-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:lib-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle::gather-operation :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle::gather-operation :precedance
 (asdf/bundle:bundle-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle::gather-operation :classof clos:standard-class)
(:mop-direct asdf/bundle::gather-operation :typeof clos:standard-class)
(:mop-direct asdf/bundle::gather-operation :superclass asdf/bundle:bundle-op)
(:mop-direct asdf/bundle::gather-operation :slot
 ((:name asdf/bundle::gather-operation) (:ordinal 1) (:allocation :class) (:readers (asdf/bundle::gather-operation))))
(:mop-direct asdf/bundle::gather-operation :slot
 ((:name asdf/bundle::gather-type) (:ordinal 2) (:allocation :class) (:initform :no-output-file) (:readers (asdf/bundle::gather-type))))
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:basic-compile-bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :precedance
 (asdf/bundle:basic-compile-bundle-op asdf/bundle:monolithic-bundle-op asdf/bundle::gather-operation asdf/bundle:bundle-op
  asdf/bundle:monolithic-op asdf/lisp-action:basic-compile-op asdf/action:non-propagating-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :prototype #<asdf/bundle:monolithic-compile-bundle-op>)
(:mop-direct asdf/bundle:dll-op :superclass asdf/bundle::link-op)
(:mop-direct asdf/bundle:dll-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:dll-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:dll-op)
(:mop-direct asdf/bundle:dll-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:dll-op :precedance
 (asdf/bundle::link-op asdf/bundle::gather-operation asdf/bundle:bundle-op asdf/action:non-propagating-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:dll-op :classof clos:standard-class)
(:mop-direct asdf/bundle:dll-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:dll-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:dll-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :object)))
(:mop-direct asdf/bundle:dll-op :slot ((:name asdf/bundle:bundle-type) (:ordinal 2) (:allocation :class) (:initform :dll)))
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:dll-op)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-dll-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-dll-op :precedance
 (asdf/bundle:dll-op asdf/bundle::link-op asdf/bundle::gather-operation asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op
  asdf/bundle:monolithic-op asdf/action:non-propagating-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-dll-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-dll-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:dll-op)
(:mop-direct asdf/bundle:monolithic-dll-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :object)))
(:mop-direct asdf/bundle:monolithic-dll-op :prototype #<asdf/bundle:monolithic-dll-op>)
(:mop-direct asdf/bundle:dll-op :prototype #<asdf/bundle:dll-op>)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/bundle:basic-compile-bundle-op)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:compile-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:compile-bundle-op :precedance
 (asdf/bundle:basic-compile-bundle-op asdf/action:selfward-operation asdf/bundle::gather-operation asdf/bundle:bundle-op
  asdf/lisp-action:basic-compile-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:compile-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:compile-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:compile-bundle-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform '(asdf/bundle:prepare-bundle-op))))
(:mop-direct asdf/bundle:compile-bundle-op :prototype #<asdf/bundle:compile-bundle-op>)
(:mop-direct asdf/bundle:lib-op :superclass asdf/bundle::link-op)
(:mop-direct asdf/bundle:lib-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:lib-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:lib-op)
(:mop-direct asdf/bundle:lib-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:lib-op :precedance
 (asdf/bundle::link-op asdf/bundle::gather-operation asdf/bundle:bundle-op asdf/action:non-propagating-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:lib-op :classof clos:standard-class)
(:mop-direct asdf/bundle:lib-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:lib-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:lib-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :object)))
(:mop-direct asdf/bundle:lib-op :slot ((:name asdf/bundle:bundle-type) (:ordinal 2) (:allocation :class) (:initform :lib)))
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:lib-op)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-lib-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-lib-op :precedance
 (asdf/bundle:lib-op asdf/bundle::link-op asdf/bundle::gather-operation asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op
  asdf/bundle:monolithic-op asdf/action:non-propagating-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-lib-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-lib-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:lib-op)
(:mop-direct asdf/bundle:monolithic-lib-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :object)))
(:mop-direct asdf/bundle:monolithic-lib-op :prototype #<asdf/bundle:monolithic-lib-op>)
(:mop-direct asdf/bundle:lib-op :prototype #<asdf/bundle:lib-op>)
(:mop-direct asdf/bundle::gather-operation :prototype #<asdf/bundle::gather-operation>)
(:mop-direct asdf/bundle::link-op :superclass asdf/bundle:bundle-op)
(:mop-direct asdf/bundle:dll-op :superclass asdf/bundle::link-op)
(:mop-direct asdf/bundle:lib-op :superclass asdf/bundle::link-op)
(:mop-direct asdf/bundle::link-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle::link-op :precedance (asdf/bundle:bundle-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle::link-op :classof clos:standard-class)
(:mop-direct asdf/bundle::link-op :typeof clos:standard-class)
(:mop-direct asdf/bundle::link-op :superclass asdf/bundle:bundle-op)
(:mop-direct asdf/bundle:dll-op :superclass asdf/bundle::link-op)
(:mop-direct asdf/bundle:dll-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:dll-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:dll-op)
(:mop-direct asdf/bundle:dll-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:dll-op :precedance
 (asdf/bundle::link-op asdf/bundle::gather-operation asdf/bundle:bundle-op asdf/action:non-propagating-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:dll-op :classof clos:standard-class)
(:mop-direct asdf/bundle:dll-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:dll-op :superclass asdf/bundle::link-op)
(:mop-direct asdf/bundle:dll-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :object)))
(:mop-direct asdf/bundle:dll-op :slot ((:name asdf/bundle:bundle-type) (:ordinal 2) (:allocation :class) (:initform :dll)))
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:dll-op)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-dll-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-dll-op :precedance
 (asdf/bundle:dll-op asdf/bundle::link-op asdf/bundle::gather-operation asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op
  asdf/bundle:monolithic-op asdf/action:non-propagating-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-dll-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-dll-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:dll-op)
(:mop-direct asdf/bundle:monolithic-dll-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :object)))
(:mop-direct asdf/bundle:monolithic-dll-op :prototype #<asdf/bundle:monolithic-dll-op>)
(:mop-direct asdf/bundle:dll-op :prototype #<asdf/bundle:dll-op>)
(:mop-direct asdf/bundle:lib-op :superclass asdf/bundle::link-op)
(:mop-direct asdf/bundle:lib-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:lib-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:lib-op)
(:mop-direct asdf/bundle:lib-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:lib-op :precedance
 (asdf/bundle::link-op asdf/bundle::gather-operation asdf/bundle:bundle-op asdf/action:non-propagating-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:lib-op :classof clos:standard-class)
(:mop-direct asdf/bundle:lib-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:lib-op :superclass asdf/bundle::link-op)
(:mop-direct asdf/bundle:lib-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :object)))
(:mop-direct asdf/bundle:lib-op :slot ((:name asdf/bundle:bundle-type) (:ordinal 2) (:allocation :class) (:initform :lib)))
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:lib-op)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-lib-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-lib-op :precedance
 (asdf/bundle:lib-op asdf/bundle::link-op asdf/bundle::gather-operation asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op
  asdf/bundle:monolithic-op asdf/action:non-propagating-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-lib-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-lib-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:lib-op)
(:mop-direct asdf/bundle:monolithic-lib-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :object)))
(:mop-direct asdf/bundle:monolithic-lib-op :prototype #<asdf/bundle:monolithic-lib-op>)
(:mop-direct asdf/bundle:lib-op :prototype #<asdf/bundle:lib-op>)
(:mop-direct asdf/bundle::link-op :prototype #<asdf/bundle::link-op>)
(:mop-direct asdf/bundle:monolithic-bundle-op :superclass asdf/bundle:bundle-op)
(:mop-direct asdf/bundle:monolithic-bundle-op :superclass asdf/bundle:monolithic-op)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:image-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-bundle-op :precedance
 (asdf/bundle:bundle-op asdf/bundle:monolithic-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-bundle-op :superclass asdf/bundle:bundle-op)
(:mop-direct asdf/bundle:monolithic-bundle-op :slot
 ((:name asdf/bundle:prologue-code) (:ordinal 1) (:readers (asdf/bundle:prologue-code))
  (:writers ((common-lisp:setf asdf/bundle:prologue-code)))))
(:mop-direct asdf/bundle:monolithic-bundle-op :slot
 ((:name asdf/bundle:epilogue-code) (:ordinal 2) (:readers (asdf/bundle:epilogue-code))
  (:writers ((common-lisp:setf asdf/bundle:epilogue-code)))))
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/concatenate-source::basic-concatenate-source-op)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :precedance
 (asdf/concatenate-source::basic-concatenate-source-op asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op asdf/bundle:monolithic-op
  asdf/action:non-propagating-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :prototype #<asdf/concatenate-source:monolithic-concatenate-source-op>)
(:mop-direct asdf/bundle:image-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:image-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:program-op :superclass asdf/bundle:image-op)
(:mop-direct asdf/bundle:image-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:image-op :precedance
 (asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op asdf/bundle:monolithic-op asdf/action:selfward-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:image-op :classof clos:standard-class)
(:mop-direct asdf/bundle:image-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:image-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:image-op :slot ((:name asdf/bundle:bundle-type) (:ordinal 1) (:allocation :class) (:initform :image)))
(:mop-direct asdf/bundle:image-op :slot
 ((:name asdf/bundle::gather-operation) (:ordinal 2) (:allocation :class) (:initform 'asdf/bundle:lib-op)))
(:mop-direct asdf/bundle:image-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 3) (:allocation :class) (:initform '(asdf/lisp-action:load-op))))
(:mop-direct asdf/bundle:program-op :superclass asdf/bundle:image-op)
(:mop-direct asdf/bundle:program-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:program-op :precedance
 (asdf/bundle:image-op asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op asdf/bundle:monolithic-op asdf/action:selfward-operation
  asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:program-op :classof clos:standard-class)
(:mop-direct asdf/bundle:program-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:program-op :superclass asdf/bundle:image-op)
(:mop-direct asdf/bundle:program-op :slot ((:name asdf/bundle:bundle-type) (:ordinal 1) (:allocation :class) (:initform :program)))
(:mop-direct asdf/bundle:program-op :prototype #<asdf/bundle:program-op>)
(:mop-direct asdf/bundle:image-op :prototype #<asdf/bundle:image-op>)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:dll-op)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-dll-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-dll-op :precedance
 (asdf/bundle:dll-op asdf/bundle::link-op asdf/bundle::gather-operation asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op
  asdf/bundle:monolithic-op asdf/action:non-propagating-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-dll-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-dll-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-dll-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :object)))
(:mop-direct asdf/bundle:monolithic-dll-op :prototype #<asdf/bundle:monolithic-dll-op>)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:lib-op)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-lib-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-lib-op :precedance
 (asdf/bundle:lib-op asdf/bundle::link-op asdf/bundle::gather-operation asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op
  asdf/bundle:monolithic-op asdf/action:non-propagating-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-lib-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-lib-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-lib-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :object)))
(:mop-direct asdf/bundle:monolithic-lib-op :prototype #<asdf/bundle:monolithic-lib-op>)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :superclass asdf/bundle:load-bundle-op)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-load-bundle-op :precedance
 (asdf/bundle:load-bundle-op asdf/lisp-action:basic-load-op asdf/action:selfward-operation asdf/bundle:monolithic-bundle-op
  asdf/bundle:bundle-op asdf/bundle:monolithic-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-load-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform 'asdf/bundle:monolithic-compile-bundle-op)))
(:mop-direct asdf/bundle:monolithic-load-bundle-op :prototype #<asdf/bundle:monolithic-load-bundle-op>)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:basic-compile-bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :precedance
 (asdf/bundle:basic-compile-bundle-op asdf/bundle:monolithic-bundle-op asdf/bundle::gather-operation asdf/bundle:bundle-op
  asdf/bundle:monolithic-op asdf/lisp-action:basic-compile-op asdf/action:non-propagating-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :prototype #<asdf/bundle:monolithic-compile-bundle-op>)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :superclass asdf/bundle:deliver-asd-op)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :precedance
 (asdf/bundle:deliver-asd-op asdf/lisp-action:basic-compile-op asdf/action:selfward-operation asdf/bundle:monolithic-bundle-op
  asdf/bundle:bundle-op asdf/bundle:monolithic-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform '(asdf/bundle:monolithic-compile-bundle-op))))
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :prototype #<asdf/bundle:monolithic-deliver-asd-op>)
(:mop-direct asdf/bundle:monolithic-bundle-op :prototype #<asdf/bundle:monolithic-bundle-op>)
(:mop-direct asdf/bundle:bundle-op :prototype #<asdf/bundle:bundle-op>)
(:mop-direct asdf/lisp-action:basic-compile-op :superclass asdf/operation:operation)
(:mop-direct asdf/concatenate-source::basic-compile-concatenated-source-op :superclass asdf/lisp-action:basic-compile-op)
(:mop-direct asdf/bundle:deliver-asd-op :superclass asdf/lisp-action:basic-compile-op)
(:mop-direct asdf/bundle:basic-compile-bundle-op :superclass asdf/lisp-action:basic-compile-op)
(:mop-direct asdf/lisp-action:compile-op :superclass asdf/lisp-action:basic-compile-op)
(:mop-direct asdf/lisp-action:basic-compile-op :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:basic-compile-op :precedance (asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/lisp-action:basic-compile-op :classof clos:standard-class)
(:mop-direct asdf/lisp-action:basic-compile-op :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:basic-compile-op :superclass asdf/operation:operation)
(:mop-direct asdf/concatenate-source::basic-compile-concatenated-source-op :superclass asdf/lisp-action:basic-compile-op)
(:mop-direct asdf/concatenate-source::basic-compile-concatenated-source-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/concatenate-source:monolithic-compile-concatenated-source-op :superclass
 asdf/concatenate-source::basic-compile-concatenated-source-op)
(:mop-direct asdf/concatenate-source:compile-concatenated-source-op :superclass asdf/concatenate-source::basic-compile-concatenated-source-op)
(:mop-direct asdf/concatenate-source::basic-compile-concatenated-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source::basic-compile-concatenated-source-op :precedance
 (asdf/lisp-action:basic-compile-op asdf/action:selfward-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source::basic-compile-concatenated-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source::basic-compile-concatenated-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source::basic-compile-concatenated-source-op :superclass asdf/lisp-action:basic-compile-op)
(:mop-direct asdf/concatenate-source:monolithic-compile-concatenated-source-op :superclass
 asdf/concatenate-source::basic-compile-concatenated-source-op)
(:mop-direct asdf/concatenate-source:monolithic-compile-concatenated-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source:monolithic-compile-concatenated-source-op :precedance
 (asdf/concatenate-source::basic-compile-concatenated-source-op asdf/lisp-action:basic-compile-op asdf/action:selfward-operation
  asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source:monolithic-compile-concatenated-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-compile-concatenated-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-compile-concatenated-source-op :superclass
 asdf/concatenate-source::basic-compile-concatenated-source-op)
(:mop-direct asdf/concatenate-source:monolithic-compile-concatenated-source-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class)
  (:initform 'asdf/concatenate-source:monolithic-concatenate-source-op)))
(:mop-direct asdf/concatenate-source:monolithic-compile-concatenated-source-op :prototype
 #<asdf/concatenate-source:monolithic-compile-concatenated-source-op>)
(:mop-direct asdf/concatenate-source:compile-concatenated-source-op :superclass asdf/concatenate-source::basic-compile-concatenated-source-op)
(:mop-direct asdf/concatenate-source:compile-concatenated-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source:compile-concatenated-source-op :precedance
 (asdf/concatenate-source::basic-compile-concatenated-source-op asdf/lisp-action:basic-compile-op asdf/action:selfward-operation
  asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source:compile-concatenated-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source:compile-concatenated-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source:compile-concatenated-source-op :superclass asdf/concatenate-source::basic-compile-concatenated-source-op)
(:mop-direct asdf/concatenate-source:compile-concatenated-source-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class)
  (:initform '(asdf/lisp-action:prepare-op asdf/concatenate-source:concatenate-source-op))))
(:mop-direct asdf/concatenate-source:compile-concatenated-source-op :prototype #<asdf/concatenate-source:compile-concatenated-source-op>)
(:mop-direct asdf/concatenate-source::basic-compile-concatenated-source-op :prototype
 #<asdf/concatenate-source::basic-compile-concatenated-source-op>)
(:mop-direct asdf/bundle:deliver-asd-op :superclass asdf/lisp-action:basic-compile-op)
(:mop-direct asdf/bundle:deliver-asd-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :superclass asdf/bundle:deliver-asd-op)
(:mop-direct asdf/bundle:deliver-asd-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:deliver-asd-op :precedance
 (asdf/lisp-action:basic-compile-op asdf/action:selfward-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:deliver-asd-op :classof clos:standard-class)
(:mop-direct asdf/bundle:deliver-asd-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:deliver-asd-op :superclass asdf/lisp-action:basic-compile-op)
(:mop-direct asdf/bundle:deliver-asd-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform '(asdf/bundle:compile-bundle-op))))
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :superclass asdf/bundle:deliver-asd-op)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :precedance
 (asdf/bundle:deliver-asd-op asdf/lisp-action:basic-compile-op asdf/action:selfward-operation asdf/bundle:monolithic-bundle-op
  asdf/bundle:bundle-op asdf/bundle:monolithic-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :superclass asdf/bundle:deliver-asd-op)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform '(asdf/bundle:monolithic-compile-bundle-op))))
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :prototype #<asdf/bundle:monolithic-deliver-asd-op>)
(:mop-direct asdf/bundle:deliver-asd-op :prototype #<asdf/bundle:deliver-asd-op>)
(:mop-direct asdf/bundle:basic-compile-bundle-op :superclass asdf/bundle:bundle-op)
(:mop-direct asdf/bundle:basic-compile-bundle-op :superclass asdf/lisp-action:basic-compile-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:basic-compile-bundle-op)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/bundle:basic-compile-bundle-op)
(:mop-direct asdf/bundle:basic-compile-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:basic-compile-bundle-op :precedance
 (asdf/bundle:bundle-op asdf/lisp-action:basic-compile-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:basic-compile-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:basic-compile-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:basic-compile-bundle-op :superclass asdf/lisp-action:basic-compile-op)
(:mop-direct asdf/bundle:basic-compile-bundle-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :fasl)))
(:mop-direct asdf/bundle:basic-compile-bundle-op :slot ((:name asdf/bundle:bundle-type) (:ordinal 2) (:allocation :class) (:initform :fasb)))
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:basic-compile-bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :precedance
 (asdf/bundle:basic-compile-bundle-op asdf/bundle:monolithic-bundle-op asdf/bundle::gather-operation asdf/bundle:bundle-op
  asdf/bundle:monolithic-op asdf/lisp-action:basic-compile-op asdf/action:non-propagating-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:basic-compile-bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :prototype #<asdf/bundle:monolithic-compile-bundle-op>)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/bundle:basic-compile-bundle-op)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:compile-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:compile-bundle-op :precedance
 (asdf/bundle:basic-compile-bundle-op asdf/action:selfward-operation asdf/bundle::gather-operation asdf/bundle:bundle-op
  asdf/lisp-action:basic-compile-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:compile-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:compile-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/bundle:basic-compile-bundle-op)
(:mop-direct asdf/bundle:compile-bundle-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform '(asdf/bundle:prepare-bundle-op))))
(:mop-direct asdf/bundle:compile-bundle-op :prototype #<asdf/bundle:compile-bundle-op>)
(:mop-direct asdf/bundle:basic-compile-bundle-op :prototype #<asdf/bundle:basic-compile-bundle-op>)
(:mop-direct asdf/lisp-action:compile-op :superclass asdf/lisp-action:basic-compile-op)
(:mop-direct asdf/lisp-action:compile-op :superclass asdf/action:downward-operation)
(:mop-direct asdf/lisp-action:compile-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/lisp-action:compile-op :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:compile-op :precedance
 (asdf/lisp-action:basic-compile-op asdf/action:downward-operation asdf/action:selfward-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/lisp-action:compile-op :classof clos:standard-class)
(:mop-direct asdf/lisp-action:compile-op :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:compile-op :superclass asdf/lisp-action:basic-compile-op)
(:mop-direct asdf/lisp-action:compile-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform 'asdf/lisp-action:prepare-op)))
(:mop-direct asdf/lisp-action:compile-op :prototype #<asdf/lisp-action:compile-op>)
(:mop-direct asdf/lisp-action:basic-compile-op :prototype #<asdf/lisp-action:basic-compile-op>)
(:mop-direct asdf/lisp-action:basic-load-op :superclass asdf/operation:operation)
(:mop-direct asdf/concatenate-source::basic-load-compiled-concatenated-source-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/concatenate-source::basic-load-concatenated-source-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/bundle:load-bundle-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/lisp-action:load-source-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/lisp-action:load-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/lisp-action:basic-load-op :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:basic-load-op :precedance (asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/lisp-action:basic-load-op :classof clos:standard-class)
(:mop-direct asdf/lisp-action:basic-load-op :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:basic-load-op :superclass asdf/operation:operation)
(:mop-direct asdf/concatenate-source::basic-load-compiled-concatenated-source-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/concatenate-source::basic-load-compiled-concatenated-source-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op :superclass
 asdf/concatenate-source::basic-load-compiled-concatenated-source-op)
(:mop-direct asdf/concatenate-source:load-compiled-concatenated-source-op :superclass
 asdf/concatenate-source::basic-load-compiled-concatenated-source-op)
(:mop-direct asdf/concatenate-source::basic-load-compiled-concatenated-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source::basic-load-compiled-concatenated-source-op :precedance
 (asdf/lisp-action:basic-load-op asdf/action:selfward-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source::basic-load-compiled-concatenated-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source::basic-load-compiled-concatenated-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source::basic-load-compiled-concatenated-source-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op :superclass
 asdf/concatenate-source::basic-load-compiled-concatenated-source-op)
(:mop-direct asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op :precedance
 (asdf/concatenate-source::basic-load-compiled-concatenated-source-op asdf/lisp-action:basic-load-op asdf/action:selfward-operation
  asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op :superclass
 asdf/concatenate-source::basic-load-compiled-concatenated-source-op)
(:mop-direct asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class)
  (:initform 'asdf/concatenate-source:monolithic-compile-concatenated-source-op)))
(:mop-direct asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op :prototype
 #<asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op>)
(:mop-direct asdf/concatenate-source:load-compiled-concatenated-source-op :superclass
 asdf/concatenate-source::basic-load-compiled-concatenated-source-op)
(:mop-direct asdf/concatenate-source:load-compiled-concatenated-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source:load-compiled-concatenated-source-op :precedance
 (asdf/concatenate-source::basic-load-compiled-concatenated-source-op asdf/lisp-action:basic-load-op asdf/action:selfward-operation
  asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source:load-compiled-concatenated-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source:load-compiled-concatenated-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source:load-compiled-concatenated-source-op :superclass
 asdf/concatenate-source::basic-load-compiled-concatenated-source-op)
(:mop-direct asdf/concatenate-source:load-compiled-concatenated-source-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class)
  (:initform '(asdf/lisp-action:prepare-op asdf/concatenate-source:compile-concatenated-source-op))))
(:mop-direct asdf/concatenate-source:load-compiled-concatenated-source-op :prototype
 #<asdf/concatenate-source:load-compiled-concatenated-source-op>)
(:mop-direct asdf/concatenate-source::basic-load-compiled-concatenated-source-op :prototype
 #<asdf/concatenate-source::basic-load-compiled-concatenated-source-op>)
(:mop-direct asdf/concatenate-source::basic-load-concatenated-source-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/concatenate-source::basic-load-concatenated-source-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/concatenate-source:monolithic-load-concatenated-source-op :superclass
 asdf/concatenate-source::basic-load-concatenated-source-op)
(:mop-direct asdf/concatenate-source:load-concatenated-source-op :superclass asdf/concatenate-source::basic-load-concatenated-source-op)
(:mop-direct asdf/concatenate-source::basic-load-concatenated-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source::basic-load-concatenated-source-op :precedance
 (asdf/lisp-action:basic-load-op asdf/action:selfward-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source::basic-load-concatenated-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source::basic-load-concatenated-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source::basic-load-concatenated-source-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/concatenate-source:monolithic-load-concatenated-source-op :superclass
 asdf/concatenate-source::basic-load-concatenated-source-op)
(:mop-direct asdf/concatenate-source:monolithic-load-concatenated-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source:monolithic-load-concatenated-source-op :precedance
 (asdf/concatenate-source::basic-load-concatenated-source-op asdf/lisp-action:basic-load-op asdf/action:selfward-operation
  asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source:monolithic-load-concatenated-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-load-concatenated-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-load-concatenated-source-op :superclass
 asdf/concatenate-source::basic-load-concatenated-source-op)
(:mop-direct asdf/concatenate-source:monolithic-load-concatenated-source-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class)
  (:initform 'asdf/concatenate-source:monolithic-concatenate-source-op)))
(:mop-direct asdf/concatenate-source:monolithic-load-concatenated-source-op :prototype
 #<asdf/concatenate-source:monolithic-load-concatenated-source-op>)
(:mop-direct asdf/concatenate-source:load-concatenated-source-op :superclass asdf/concatenate-source::basic-load-concatenated-source-op)
(:mop-direct asdf/concatenate-source:load-concatenated-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source:load-concatenated-source-op :precedance
 (asdf/concatenate-source::basic-load-concatenated-source-op asdf/lisp-action:basic-load-op asdf/action:selfward-operation
  asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source:load-concatenated-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source:load-concatenated-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source:load-concatenated-source-op :superclass asdf/concatenate-source::basic-load-concatenated-source-op)
(:mop-direct asdf/concatenate-source:load-concatenated-source-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class)
  (:initform '(asdf/lisp-action:prepare-op asdf/concatenate-source:concatenate-source-op))))
(:mop-direct asdf/concatenate-source:load-concatenated-source-op :prototype #<asdf/concatenate-source:load-concatenated-source-op>)
(:mop-direct asdf/concatenate-source::basic-load-concatenated-source-op :prototype
 #<asdf/concatenate-source::basic-load-concatenated-source-op>)
(:mop-direct asdf/bundle:load-bundle-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/bundle:load-bundle-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :superclass asdf/bundle:load-bundle-op)
(:mop-direct asdf/bundle:load-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:load-bundle-op :precedance
 (asdf/lisp-action:basic-load-op asdf/action:selfward-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:load-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:load-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:load-bundle-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/bundle:load-bundle-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class)
  (:initform '(asdf/bundle:prepare-bundle-op asdf/bundle:compile-bundle-op))))
(:mop-direct asdf/bundle:monolithic-load-bundle-op :superclass asdf/bundle:load-bundle-op)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-load-bundle-op :precedance
 (asdf/bundle:load-bundle-op asdf/lisp-action:basic-load-op asdf/action:selfward-operation asdf/bundle:monolithic-bundle-op
  asdf/bundle:bundle-op asdf/bundle:monolithic-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-load-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :superclass asdf/bundle:load-bundle-op)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform 'asdf/bundle:monolithic-compile-bundle-op)))
(:mop-direct asdf/bundle:monolithic-load-bundle-op :prototype #<asdf/bundle:monolithic-load-bundle-op>)
(:mop-direct asdf/bundle:load-bundle-op :prototype #<asdf/bundle:load-bundle-op>)
(:mop-direct asdf/lisp-action:load-source-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/lisp-action:load-source-op :superclass asdf/action:downward-operation)
(:mop-direct asdf/lisp-action:load-source-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/lisp-action:load-source-op :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:load-source-op :precedance
 (asdf/lisp-action:basic-load-op asdf/action:downward-operation asdf/action:selfward-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/lisp-action:load-source-op :classof clos:standard-class)
(:mop-direct asdf/lisp-action:load-source-op :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:load-source-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/lisp-action:load-source-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform 'asdf/lisp-action:prepare-source-op)))
(:mop-direct asdf/lisp-action:load-source-op :prototype #<asdf/lisp-action:load-source-op>)
(:mop-direct asdf/lisp-action:load-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/lisp-action:load-op :superclass asdf/action:downward-operation)
(:mop-direct asdf/lisp-action:load-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/lisp-action:load-op :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:load-op :precedance
 (asdf/lisp-action:basic-load-op asdf/action:downward-operation asdf/action:selfward-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/lisp-action:load-op :classof clos:standard-class)
(:mop-direct asdf/lisp-action:load-op :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:load-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/lisp-action:load-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class)
  (:initform '(asdf/lisp-action:prepare-op asdf/lisp-action:compile-op))))
(:mop-direct asdf/lisp-action:load-op :prototype #<asdf/lisp-action:load-op>)
(:mop-direct asdf/lisp-action:basic-load-op :prototype #<asdf/lisp-action:basic-load-op>)
(:mop-direct asdf/action:non-propagating-operation :superclass asdf/operation:operation)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/concatenate-source:concatenate-source-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:dll-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:lib-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/find-system:define-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/operate:build-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/action:non-propagating-operation :package-name "ASDF/ACTION")
(:mop-direct asdf/action:non-propagating-operation :precedance (asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/action:non-propagating-operation :classof clos:standard-class)
(:mop-direct asdf/action:non-propagating-operation :typeof clos:standard-class)
(:mop-direct asdf/action:non-propagating-operation :superclass asdf/operation:operation)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/concatenate-source::basic-concatenate-source-op)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :precedance
 (asdf/concatenate-source::basic-concatenate-source-op asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op asdf/bundle:monolithic-op
  asdf/action:non-propagating-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/concatenate-source:monolithic-concatenate-source-op :prototype #<asdf/concatenate-source:monolithic-concatenate-source-op>)
(:mop-direct asdf/concatenate-source:concatenate-source-op :superclass asdf/concatenate-source::basic-concatenate-source-op)
(:mop-direct asdf/concatenate-source:concatenate-source-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/concatenate-source:concatenate-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source:concatenate-source-op :precedance
 (asdf/concatenate-source::basic-concatenate-source-op asdf/bundle:bundle-op asdf/action:non-propagating-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source:concatenate-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source:concatenate-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source:concatenate-source-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/concatenate-source:concatenate-source-op :prototype #<asdf/concatenate-source:concatenate-source-op>)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:dll-op)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-dll-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-dll-op :precedance
 (asdf/bundle:dll-op asdf/bundle::link-op asdf/bundle::gather-operation asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op
  asdf/bundle:monolithic-op asdf/action:non-propagating-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-dll-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-dll-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-dll-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :object)))
(:mop-direct asdf/bundle:monolithic-dll-op :prototype #<asdf/bundle:monolithic-dll-op>)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:lib-op)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-lib-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-lib-op :precedance
 (asdf/bundle:lib-op asdf/bundle::link-op asdf/bundle::gather-operation asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op
  asdf/bundle:monolithic-op asdf/action:non-propagating-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-lib-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-lib-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-lib-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :object)))
(:mop-direct asdf/bundle:monolithic-lib-op :prototype #<asdf/bundle:monolithic-lib-op>)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:basic-compile-bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :precedance
 (asdf/bundle:basic-compile-bundle-op asdf/bundle:monolithic-bundle-op asdf/bundle::gather-operation asdf/bundle:bundle-op
  asdf/bundle:monolithic-op asdf/lisp-action:basic-compile-op asdf/action:non-propagating-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-compile-bundle-op :prototype #<asdf/bundle:monolithic-compile-bundle-op>)
(:mop-direct asdf/bundle:dll-op :superclass asdf/bundle::link-op)
(:mop-direct asdf/bundle:dll-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:dll-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:dll-op)
(:mop-direct asdf/bundle:dll-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:dll-op :precedance
 (asdf/bundle::link-op asdf/bundle::gather-operation asdf/bundle:bundle-op asdf/action:non-propagating-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:dll-op :classof clos:standard-class)
(:mop-direct asdf/bundle:dll-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:dll-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:dll-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :object)))
(:mop-direct asdf/bundle:dll-op :slot ((:name asdf/bundle:bundle-type) (:ordinal 2) (:allocation :class) (:initform :dll)))
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:dll-op)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-dll-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-dll-op :precedance
 (asdf/bundle:dll-op asdf/bundle::link-op asdf/bundle::gather-operation asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op
  asdf/bundle:monolithic-op asdf/action:non-propagating-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-dll-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-dll-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-dll-op :superclass asdf/bundle:dll-op)
(:mop-direct asdf/bundle:monolithic-dll-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :object)))
(:mop-direct asdf/bundle:monolithic-dll-op :prototype #<asdf/bundle:monolithic-dll-op>)
(:mop-direct asdf/bundle:dll-op :prototype #<asdf/bundle:dll-op>)
(:mop-direct asdf/bundle:lib-op :superclass asdf/bundle::link-op)
(:mop-direct asdf/bundle:lib-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:lib-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:lib-op)
(:mop-direct asdf/bundle:lib-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:lib-op :precedance
 (asdf/bundle::link-op asdf/bundle::gather-operation asdf/bundle:bundle-op asdf/action:non-propagating-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:lib-op :classof clos:standard-class)
(:mop-direct asdf/bundle:lib-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:lib-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:lib-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :object)))
(:mop-direct asdf/bundle:lib-op :slot ((:name asdf/bundle:bundle-type) (:ordinal 2) (:allocation :class) (:initform :lib)))
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:lib-op)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/bundle:monolithic-lib-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-lib-op :precedance
 (asdf/bundle:lib-op asdf/bundle::link-op asdf/bundle::gather-operation asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op
  asdf/bundle:monolithic-op asdf/action:non-propagating-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-lib-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-lib-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-lib-op :superclass asdf/bundle:lib-op)
(:mop-direct asdf/bundle:monolithic-lib-op :slot ((:name asdf/bundle::gather-type) (:ordinal 1) (:allocation :class) (:initform :object)))
(:mop-direct asdf/bundle:monolithic-lib-op :prototype #<asdf/bundle:monolithic-lib-op>)
(:mop-direct asdf/bundle:lib-op :prototype #<asdf/bundle:lib-op>)
(:mop-direct asdf/find-system:define-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/find-system:define-op :package-name "ASDF/FIND-SYSTEM")
(:mop-direct asdf/find-system:define-op :precedance
 (asdf/action:non-propagating-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/find-system:define-op :classof clos:standard-class)
(:mop-direct asdf/find-system:define-op :typeof clos:standard-class)
(:mop-direct asdf/find-system:define-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/find-system:define-op :prototype #<asdf/find-system:define-op>)
(:mop-direct asdf/operate:build-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/operate:build-op :package-name "ASDF/OPERATE")
(:mop-direct asdf/operate:build-op :precedance
 (asdf/action:non-propagating-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/operate:build-op :classof clos:standard-class)
(:mop-direct asdf/operate:build-op :typeof clos:standard-class)
(:mop-direct asdf/operate:build-op :superclass asdf/action:non-propagating-operation)
(:mop-direct asdf/operate:build-op :prototype #<asdf/operate:build-op>)
(:mop-direct asdf/action:non-propagating-operation :prototype #<asdf/action:non-propagating-operation>)
(:mop-direct asdf/action:selfward-operation :superclass asdf/operation:operation)
(:mop-direct asdf/concatenate-source::basic-load-compiled-concatenated-source-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/concatenate-source::basic-compile-concatenated-source-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/concatenate-source::basic-load-concatenated-source-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:image-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:deliver-asd-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:load-bundle-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/lisp-action:test-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/lisp-action:load-source-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/lisp-action:compile-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/lisp-action:load-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/action:selfward-operation :package-name "ASDF/ACTION")
(:mop-direct asdf/action:selfward-operation :precedance (asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/action:selfward-operation :classof clos:standard-class)
(:mop-direct asdf/action:selfward-operation :typeof clos:standard-class)
(:mop-direct asdf/action:selfward-operation :superclass asdf/operation:operation)
(:mop-direct asdf/action:selfward-operation :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class)
  (:type (common-lisp:or asdf/action::operation-designator common-lisp:list)) (:readers (asdf/action:selfward-operation))))
(:mop-direct asdf/concatenate-source::basic-load-compiled-concatenated-source-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/concatenate-source::basic-load-compiled-concatenated-source-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op :superclass
 asdf/concatenate-source::basic-load-compiled-concatenated-source-op)
(:mop-direct asdf/concatenate-source:load-compiled-concatenated-source-op :superclass
 asdf/concatenate-source::basic-load-compiled-concatenated-source-op)
(:mop-direct asdf/concatenate-source::basic-load-compiled-concatenated-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source::basic-load-compiled-concatenated-source-op :precedance
 (asdf/lisp-action:basic-load-op asdf/action:selfward-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source::basic-load-compiled-concatenated-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source::basic-load-compiled-concatenated-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source::basic-load-compiled-concatenated-source-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op :superclass
 asdf/concatenate-source::basic-load-compiled-concatenated-source-op)
(:mop-direct asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op :precedance
 (asdf/concatenate-source::basic-load-compiled-concatenated-source-op asdf/lisp-action:basic-load-op asdf/action:selfward-operation
  asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op :superclass
 asdf/concatenate-source::basic-load-compiled-concatenated-source-op)
(:mop-direct asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class)
  (:initform 'asdf/concatenate-source:monolithic-compile-concatenated-source-op)))
(:mop-direct asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op :prototype
 #<asdf/concatenate-source:monolithic-load-compiled-concatenated-source-op>)
(:mop-direct asdf/concatenate-source:load-compiled-concatenated-source-op :superclass
 asdf/concatenate-source::basic-load-compiled-concatenated-source-op)
(:mop-direct asdf/concatenate-source:load-compiled-concatenated-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source:load-compiled-concatenated-source-op :precedance
 (asdf/concatenate-source::basic-load-compiled-concatenated-source-op asdf/lisp-action:basic-load-op asdf/action:selfward-operation
  asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source:load-compiled-concatenated-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source:load-compiled-concatenated-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source:load-compiled-concatenated-source-op :superclass
 asdf/concatenate-source::basic-load-compiled-concatenated-source-op)
(:mop-direct asdf/concatenate-source:load-compiled-concatenated-source-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class)
  (:initform '(asdf/lisp-action:prepare-op asdf/concatenate-source:compile-concatenated-source-op))))
(:mop-direct asdf/concatenate-source:load-compiled-concatenated-source-op :prototype
 #<asdf/concatenate-source:load-compiled-concatenated-source-op>)
(:mop-direct asdf/concatenate-source::basic-load-compiled-concatenated-source-op :prototype
 #<asdf/concatenate-source::basic-load-compiled-concatenated-source-op>)
(:mop-direct asdf/concatenate-source::basic-compile-concatenated-source-op :superclass asdf/lisp-action:basic-compile-op)
(:mop-direct asdf/concatenate-source::basic-compile-concatenated-source-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/concatenate-source:monolithic-compile-concatenated-source-op :superclass
 asdf/concatenate-source::basic-compile-concatenated-source-op)
(:mop-direct asdf/concatenate-source:compile-concatenated-source-op :superclass asdf/concatenate-source::basic-compile-concatenated-source-op)
(:mop-direct asdf/concatenate-source::basic-compile-concatenated-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source::basic-compile-concatenated-source-op :precedance
 (asdf/lisp-action:basic-compile-op asdf/action:selfward-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source::basic-compile-concatenated-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source::basic-compile-concatenated-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source::basic-compile-concatenated-source-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/concatenate-source:monolithic-compile-concatenated-source-op :superclass
 asdf/concatenate-source::basic-compile-concatenated-source-op)
(:mop-direct asdf/concatenate-source:monolithic-compile-concatenated-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source:monolithic-compile-concatenated-source-op :precedance
 (asdf/concatenate-source::basic-compile-concatenated-source-op asdf/lisp-action:basic-compile-op asdf/action:selfward-operation
  asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source:monolithic-compile-concatenated-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-compile-concatenated-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-compile-concatenated-source-op :superclass
 asdf/concatenate-source::basic-compile-concatenated-source-op)
(:mop-direct asdf/concatenate-source:monolithic-compile-concatenated-source-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class)
  (:initform 'asdf/concatenate-source:monolithic-concatenate-source-op)))
(:mop-direct asdf/concatenate-source:monolithic-compile-concatenated-source-op :prototype
 #<asdf/concatenate-source:monolithic-compile-concatenated-source-op>)
(:mop-direct asdf/concatenate-source:compile-concatenated-source-op :superclass asdf/concatenate-source::basic-compile-concatenated-source-op)
(:mop-direct asdf/concatenate-source:compile-concatenated-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source:compile-concatenated-source-op :precedance
 (asdf/concatenate-source::basic-compile-concatenated-source-op asdf/lisp-action:basic-compile-op asdf/action:selfward-operation
  asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source:compile-concatenated-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source:compile-concatenated-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source:compile-concatenated-source-op :superclass asdf/concatenate-source::basic-compile-concatenated-source-op)
(:mop-direct asdf/concatenate-source:compile-concatenated-source-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class)
  (:initform '(asdf/lisp-action:prepare-op asdf/concatenate-source:concatenate-source-op))))
(:mop-direct asdf/concatenate-source:compile-concatenated-source-op :prototype #<asdf/concatenate-source:compile-concatenated-source-op>)
(:mop-direct asdf/concatenate-source::basic-compile-concatenated-source-op :prototype
 #<asdf/concatenate-source::basic-compile-concatenated-source-op>)
(:mop-direct asdf/concatenate-source::basic-load-concatenated-source-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/concatenate-source::basic-load-concatenated-source-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/concatenate-source:monolithic-load-concatenated-source-op :superclass
 asdf/concatenate-source::basic-load-concatenated-source-op)
(:mop-direct asdf/concatenate-source:load-concatenated-source-op :superclass asdf/concatenate-source::basic-load-concatenated-source-op)
(:mop-direct asdf/concatenate-source::basic-load-concatenated-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source::basic-load-concatenated-source-op :precedance
 (asdf/lisp-action:basic-load-op asdf/action:selfward-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source::basic-load-concatenated-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source::basic-load-concatenated-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source::basic-load-concatenated-source-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/concatenate-source:monolithic-load-concatenated-source-op :superclass
 asdf/concatenate-source::basic-load-concatenated-source-op)
(:mop-direct asdf/concatenate-source:monolithic-load-concatenated-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source:monolithic-load-concatenated-source-op :precedance
 (asdf/concatenate-source::basic-load-concatenated-source-op asdf/lisp-action:basic-load-op asdf/action:selfward-operation
  asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source:monolithic-load-concatenated-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-load-concatenated-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source:monolithic-load-concatenated-source-op :superclass
 asdf/concatenate-source::basic-load-concatenated-source-op)
(:mop-direct asdf/concatenate-source:monolithic-load-concatenated-source-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class)
  (:initform 'asdf/concatenate-source:monolithic-concatenate-source-op)))
(:mop-direct asdf/concatenate-source:monolithic-load-concatenated-source-op :prototype
 #<asdf/concatenate-source:monolithic-load-concatenated-source-op>)
(:mop-direct asdf/concatenate-source:load-concatenated-source-op :superclass asdf/concatenate-source::basic-load-concatenated-source-op)
(:mop-direct asdf/concatenate-source:load-concatenated-source-op :package-name "ASDF/CONCATENATE-SOURCE")
(:mop-direct asdf/concatenate-source:load-concatenated-source-op :precedance
 (asdf/concatenate-source::basic-load-concatenated-source-op asdf/lisp-action:basic-load-op asdf/action:selfward-operation
  asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/concatenate-source:load-concatenated-source-op :classof clos:standard-class)
(:mop-direct asdf/concatenate-source:load-concatenated-source-op :typeof clos:standard-class)
(:mop-direct asdf/concatenate-source:load-concatenated-source-op :superclass asdf/concatenate-source::basic-load-concatenated-source-op)
(:mop-direct asdf/concatenate-source:load-concatenated-source-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class)
  (:initform '(asdf/lisp-action:prepare-op asdf/concatenate-source:concatenate-source-op))))
(:mop-direct asdf/concatenate-source:load-concatenated-source-op :prototype #<asdf/concatenate-source:load-concatenated-source-op>)
(:mop-direct asdf/concatenate-source::basic-load-concatenated-source-op :prototype
 #<asdf/concatenate-source::basic-load-concatenated-source-op>)
(:mop-direct asdf/bundle:image-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:image-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:program-op :superclass asdf/bundle:image-op)
(:mop-direct asdf/bundle:image-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:image-op :precedance
 (asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op asdf/bundle:monolithic-op asdf/action:selfward-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:image-op :classof clos:standard-class)
(:mop-direct asdf/bundle:image-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:image-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:image-op :slot ((:name asdf/bundle:bundle-type) (:ordinal 1) (:allocation :class) (:initform :image)))
(:mop-direct asdf/bundle:image-op :slot
 ((:name asdf/bundle::gather-operation) (:ordinal 2) (:allocation :class) (:initform 'asdf/bundle:lib-op)))
(:mop-direct asdf/bundle:image-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 3) (:allocation :class) (:initform '(asdf/lisp-action:load-op))))
(:mop-direct asdf/bundle:program-op :superclass asdf/bundle:image-op)
(:mop-direct asdf/bundle:program-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:program-op :precedance
 (asdf/bundle:image-op asdf/bundle:monolithic-bundle-op asdf/bundle:bundle-op asdf/bundle:monolithic-op asdf/action:selfward-operation
  asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:program-op :classof clos:standard-class)
(:mop-direct asdf/bundle:program-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:program-op :superclass asdf/bundle:image-op)
(:mop-direct asdf/bundle:program-op :slot ((:name asdf/bundle:bundle-type) (:ordinal 1) (:allocation :class) (:initform :program)))
(:mop-direct asdf/bundle:program-op :prototype #<asdf/bundle:program-op>)
(:mop-direct asdf/bundle:image-op :prototype #<asdf/bundle:image-op>)
(:mop-direct asdf/bundle:deliver-asd-op :superclass asdf/lisp-action:basic-compile-op)
(:mop-direct asdf/bundle:deliver-asd-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :superclass asdf/bundle:deliver-asd-op)
(:mop-direct asdf/bundle:deliver-asd-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:deliver-asd-op :precedance
 (asdf/lisp-action:basic-compile-op asdf/action:selfward-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:deliver-asd-op :classof clos:standard-class)
(:mop-direct asdf/bundle:deliver-asd-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:deliver-asd-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:deliver-asd-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform '(asdf/bundle:compile-bundle-op))))
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :superclass asdf/bundle:deliver-asd-op)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :precedance
 (asdf/bundle:deliver-asd-op asdf/lisp-action:basic-compile-op asdf/action:selfward-operation asdf/bundle:monolithic-bundle-op
  asdf/bundle:bundle-op asdf/bundle:monolithic-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :superclass asdf/bundle:deliver-asd-op)
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform '(asdf/bundle:monolithic-compile-bundle-op))))
(:mop-direct asdf/bundle:monolithic-deliver-asd-op :prototype #<asdf/bundle:monolithic-deliver-asd-op>)
(:mop-direct asdf/bundle:deliver-asd-op :prototype #<asdf/bundle:deliver-asd-op>)
(:mop-direct asdf/bundle:load-bundle-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/bundle:load-bundle-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :superclass asdf/bundle:load-bundle-op)
(:mop-direct asdf/bundle:load-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:load-bundle-op :precedance
 (asdf/lisp-action:basic-load-op asdf/action:selfward-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:load-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:load-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:load-bundle-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:load-bundle-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class)
  (:initform '(asdf/bundle:prepare-bundle-op asdf/bundle:compile-bundle-op))))
(:mop-direct asdf/bundle:monolithic-load-bundle-op :superclass asdf/bundle:load-bundle-op)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :superclass asdf/bundle:monolithic-bundle-op)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:monolithic-load-bundle-op :precedance
 (asdf/bundle:load-bundle-op asdf/lisp-action:basic-load-op asdf/action:selfward-operation asdf/bundle:monolithic-bundle-op
  asdf/bundle:bundle-op asdf/bundle:monolithic-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:monolithic-load-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :superclass asdf/bundle:load-bundle-op)
(:mop-direct asdf/bundle:monolithic-load-bundle-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform 'asdf/bundle:monolithic-compile-bundle-op)))
(:mop-direct asdf/bundle:monolithic-load-bundle-op :prototype #<asdf/bundle:monolithic-load-bundle-op>)
(:mop-direct asdf/bundle:load-bundle-op :prototype #<asdf/bundle:load-bundle-op>)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/bundle:basic-compile-bundle-op)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/bundle::gather-operation)
(:mop-direct asdf/bundle:compile-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:compile-bundle-op :precedance
 (asdf/bundle:basic-compile-bundle-op asdf/action:selfward-operation asdf/bundle::gather-operation asdf/bundle:bundle-op
  asdf/lisp-action:basic-compile-op asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:compile-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:compile-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:compile-bundle-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/bundle:compile-bundle-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform '(asdf/bundle:prepare-bundle-op))))
(:mop-direct asdf/bundle:compile-bundle-op :prototype #<asdf/bundle:compile-bundle-op>)
(:mop-direct asdf/lisp-action:test-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/lisp-action:test-op :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:test-op :precedance
 (asdf/action:selfward-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/lisp-action:test-op :classof clos:standard-class)
(:mop-direct asdf/lisp-action:test-op :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:test-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/lisp-action:test-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform 'asdf/lisp-action:load-op)))
(:mop-direct asdf/lisp-action:test-op :prototype #<asdf/lisp-action:test-op>)
(:mop-direct asdf/lisp-action:load-source-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/lisp-action:load-source-op :superclass asdf/action:downward-operation)
(:mop-direct asdf/lisp-action:load-source-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/lisp-action:load-source-op :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:load-source-op :precedance
 (asdf/lisp-action:basic-load-op asdf/action:downward-operation asdf/action:selfward-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/lisp-action:load-source-op :classof clos:standard-class)
(:mop-direct asdf/lisp-action:load-source-op :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:load-source-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/lisp-action:load-source-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform 'asdf/lisp-action:prepare-source-op)))
(:mop-direct asdf/lisp-action:load-source-op :prototype #<asdf/lisp-action:load-source-op>)
(:mop-direct asdf/lisp-action:compile-op :superclass asdf/lisp-action:basic-compile-op)
(:mop-direct asdf/lisp-action:compile-op :superclass asdf/action:downward-operation)
(:mop-direct asdf/lisp-action:compile-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/lisp-action:compile-op :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:compile-op :precedance
 (asdf/lisp-action:basic-compile-op asdf/action:downward-operation asdf/action:selfward-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/lisp-action:compile-op :classof clos:standard-class)
(:mop-direct asdf/lisp-action:compile-op :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:compile-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/lisp-action:compile-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform 'asdf/lisp-action:prepare-op)))
(:mop-direct asdf/lisp-action:compile-op :prototype #<asdf/lisp-action:compile-op>)
(:mop-direct asdf/lisp-action:load-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/lisp-action:load-op :superclass asdf/action:downward-operation)
(:mop-direct asdf/lisp-action:load-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/lisp-action:load-op :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:load-op :precedance
 (asdf/lisp-action:basic-load-op asdf/action:downward-operation asdf/action:selfward-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/lisp-action:load-op :classof clos:standard-class)
(:mop-direct asdf/lisp-action:load-op :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:load-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/lisp-action:load-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class)
  (:initform '(asdf/lisp-action:prepare-op asdf/lisp-action:compile-op))))
(:mop-direct asdf/lisp-action:load-op :prototype #<asdf/lisp-action:load-op>)
(:mop-direct asdf/action:selfward-operation :prototype #<asdf/action:selfward-operation>)
(:mop-direct asdf/action:sideway-operation :superclass asdf/operation:operation)
(:mop-direct asdf/bundle:prepare-bundle-op :superclass asdf/action:sideway-operation)
(:mop-direct asdf/lisp-action:prepare-source-op :superclass asdf/action:sideway-operation)
(:mop-direct asdf/lisp-action:prepare-op :superclass asdf/action:sideway-operation)
(:mop-direct asdf/action:sideway-operation :package-name "ASDF/ACTION")
(:mop-direct asdf/action:sideway-operation :precedance (asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/action:sideway-operation :classof clos:standard-class)
(:mop-direct asdf/action:sideway-operation :typeof clos:standard-class)
(:mop-direct asdf/action:sideway-operation :superclass asdf/operation:operation)
(:mop-direct asdf/action:sideway-operation :slot
 ((:name asdf/action:sideway-operation) (:ordinal 1) (:allocation :class) (:type asdf/action::operation-designator)
  (:readers (asdf/action:sideway-operation))))
(:mop-direct asdf/bundle:prepare-bundle-op :superclass asdf/action:sideway-operation)
(:mop-direct asdf/bundle:prepare-bundle-op :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:prepare-bundle-op :precedance
 (asdf/action:sideway-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:prepare-bundle-op :classof clos:standard-class)
(:mop-direct asdf/bundle:prepare-bundle-op :typeof clos:standard-class)
(:mop-direct asdf/bundle:prepare-bundle-op :superclass asdf/action:sideway-operation)
(:mop-direct asdf/bundle:prepare-bundle-op :slot
 ((:name asdf/action:sideway-operation) (:ordinal 1) (:allocation :class) (:initform 'asdf/lisp-action:load-op)))
(:mop-direct asdf/bundle:prepare-bundle-op :prototype #<asdf/bundle:prepare-bundle-op>)
(:mop-direct asdf/lisp-action:prepare-source-op :superclass asdf/action:upward-operation)
(:mop-direct asdf/lisp-action:prepare-source-op :superclass asdf/action:sideway-operation)
(:mop-direct asdf/lisp-action:prepare-source-op :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:prepare-source-op :precedance
 (asdf/action:upward-operation asdf/action:sideway-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/lisp-action:prepare-source-op :classof clos:standard-class)
(:mop-direct asdf/lisp-action:prepare-source-op :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:prepare-source-op :superclass asdf/action:sideway-operation)
(:mop-direct asdf/lisp-action:prepare-source-op :slot
 ((:name asdf/action:sideway-operation) (:ordinal 1) (:allocation :class) (:initform 'asdf/lisp-action:load-source-op)))
(:mop-direct asdf/lisp-action:prepare-source-op :prototype #<asdf/lisp-action:prepare-source-op>)
(:mop-direct asdf/lisp-action:prepare-op :superclass asdf/action:upward-operation)
(:mop-direct asdf/lisp-action:prepare-op :superclass asdf/action:sideway-operation)
(:mop-direct asdf/lisp-action:prepare-op :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:prepare-op :precedance
 (asdf/action:upward-operation asdf/action:sideway-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/lisp-action:prepare-op :classof clos:standard-class)
(:mop-direct asdf/lisp-action:prepare-op :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:prepare-op :superclass asdf/action:sideway-operation)
(:mop-direct asdf/lisp-action:prepare-op :slot
 ((:name asdf/action:sideway-operation) (:ordinal 1) (:allocation :class) (:initform 'asdf/lisp-action:load-op)))
(:mop-direct asdf/lisp-action:prepare-op :prototype #<asdf/lisp-action:prepare-op>)
(:mop-direct asdf/action:sideway-operation :prototype #<asdf/action:sideway-operation>)
(:mop-direct asdf/action:upward-operation :superclass asdf/operation:operation)
(:mop-direct asdf/lisp-action:prepare-source-op :superclass asdf/action:upward-operation)
(:mop-direct asdf/lisp-action:prepare-op :superclass asdf/action:upward-operation)
(:mop-direct asdf/action:upward-operation :package-name "ASDF/ACTION")
(:mop-direct asdf/action:upward-operation :precedance (asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/action:upward-operation :classof clos:standard-class)
(:mop-direct asdf/action:upward-operation :typeof clos:standard-class)
(:mop-direct asdf/action:upward-operation :superclass asdf/operation:operation)
(:mop-direct asdf/action:upward-operation :slot
 ((:name asdf/action:upward-operation) (:ordinal 1) (:allocation :class) (:type asdf/action::operation-designator)
  (:readers (asdf/action:upward-operation))))
(:mop-direct asdf/lisp-action:prepare-source-op :superclass asdf/action:upward-operation)
(:mop-direct asdf/lisp-action:prepare-source-op :superclass asdf/action:sideway-operation)
(:mop-direct asdf/lisp-action:prepare-source-op :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:prepare-source-op :precedance
 (asdf/action:upward-operation asdf/action:sideway-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/lisp-action:prepare-source-op :classof clos:standard-class)
(:mop-direct asdf/lisp-action:prepare-source-op :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:prepare-source-op :superclass asdf/action:upward-operation)
(:mop-direct asdf/lisp-action:prepare-source-op :slot
 ((:name asdf/action:sideway-operation) (:ordinal 1) (:allocation :class) (:initform 'asdf/lisp-action:load-source-op)))
(:mop-direct asdf/lisp-action:prepare-source-op :prototype #<asdf/lisp-action:prepare-source-op>)
(:mop-direct asdf/lisp-action:prepare-op :superclass asdf/action:upward-operation)
(:mop-direct asdf/lisp-action:prepare-op :superclass asdf/action:sideway-operation)
(:mop-direct asdf/lisp-action:prepare-op :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:prepare-op :precedance
 (asdf/action:upward-operation asdf/action:sideway-operation asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/lisp-action:prepare-op :classof clos:standard-class)
(:mop-direct asdf/lisp-action:prepare-op :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:prepare-op :superclass asdf/action:upward-operation)
(:mop-direct asdf/lisp-action:prepare-op :slot
 ((:name asdf/action:sideway-operation) (:ordinal 1) (:allocation :class) (:initform 'asdf/lisp-action:load-op)))
(:mop-direct asdf/lisp-action:prepare-op :prototype #<asdf/lisp-action:prepare-op>)
(:mop-direct asdf/action:upward-operation :prototype #<asdf/action:upward-operation>)
(:mop-direct asdf/action:downward-operation :superclass asdf/operation:operation)
(:mop-direct asdf/lisp-action:load-source-op :superclass asdf/action:downward-operation)
(:mop-direct asdf/lisp-action:compile-op :superclass asdf/action:downward-operation)
(:mop-direct asdf/lisp-action:load-op :superclass asdf/action:downward-operation)
(:mop-direct asdf/action:downward-operation :package-name "ASDF/ACTION")
(:mop-direct asdf/action:downward-operation :precedance (asdf/operation:operation common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/action:downward-operation :classof clos:standard-class)
(:mop-direct asdf/action:downward-operation :typeof clos:standard-class)
(:mop-direct asdf/action:downward-operation :superclass asdf/operation:operation)
(:mop-direct asdf/action:downward-operation :slot
 ((:name asdf/action:downward-operation) (:ordinal 1) (:allocation :class) (:type asdf/action::operation-designator)
  (:readers (asdf/action:downward-operation))))
(:mop-direct asdf/lisp-action:load-source-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/lisp-action:load-source-op :superclass asdf/action:downward-operation)
(:mop-direct asdf/lisp-action:load-source-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/lisp-action:load-source-op :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:load-source-op :precedance
 (asdf/lisp-action:basic-load-op asdf/action:downward-operation asdf/action:selfward-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/lisp-action:load-source-op :classof clos:standard-class)
(:mop-direct asdf/lisp-action:load-source-op :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:load-source-op :superclass asdf/action:downward-operation)
(:mop-direct asdf/lisp-action:load-source-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform 'asdf/lisp-action:prepare-source-op)))
(:mop-direct asdf/lisp-action:load-source-op :prototype #<asdf/lisp-action:load-source-op>)
(:mop-direct asdf/lisp-action:compile-op :superclass asdf/lisp-action:basic-compile-op)
(:mop-direct asdf/lisp-action:compile-op :superclass asdf/action:downward-operation)
(:mop-direct asdf/lisp-action:compile-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/lisp-action:compile-op :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:compile-op :precedance
 (asdf/lisp-action:basic-compile-op asdf/action:downward-operation asdf/action:selfward-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/lisp-action:compile-op :classof clos:standard-class)
(:mop-direct asdf/lisp-action:compile-op :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:compile-op :superclass asdf/action:downward-operation)
(:mop-direct asdf/lisp-action:compile-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class) (:initform 'asdf/lisp-action:prepare-op)))
(:mop-direct asdf/lisp-action:compile-op :prototype #<asdf/lisp-action:compile-op>)
(:mop-direct asdf/lisp-action:load-op :superclass asdf/lisp-action:basic-load-op)
(:mop-direct asdf/lisp-action:load-op :superclass asdf/action:downward-operation)
(:mop-direct asdf/lisp-action:load-op :superclass asdf/action:selfward-operation)
(:mop-direct asdf/lisp-action:load-op :package-name "ASDF/LISP-ACTION")
(:mop-direct asdf/lisp-action:load-op :precedance
 (asdf/lisp-action:basic-load-op asdf/action:downward-operation asdf/action:selfward-operation asdf/operation:operation
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/lisp-action:load-op :classof clos:standard-class)
(:mop-direct asdf/lisp-action:load-op :typeof clos:standard-class)
(:mop-direct asdf/lisp-action:load-op :superclass asdf/action:downward-operation)
(:mop-direct asdf/lisp-action:load-op :slot
 ((:name asdf/action:selfward-operation) (:ordinal 1) (:allocation :class)
  (:initform '(asdf/lisp-action:prepare-op asdf/lisp-action:compile-op))))
(:mop-direct asdf/lisp-action:load-op :prototype #<asdf/lisp-action:load-op>)
(:mop-direct asdf/action:downward-operation :prototype #<asdf/action:downward-operation>)
(:mop-direct asdf/operation:operation :prototype #<asdf/operation:operation>)
(:mop-direct asdf/system:proto-system :superclass common-lisp:standard-object)
(:mop-direct asdf/system:system :superclass asdf/system:proto-system)
(:mop-direct asdf/system:proto-system :package-name "ASDF/SYSTEM")
(:mop-direct asdf/system:proto-system :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/system:proto-system :classof clos:standard-class)
(:mop-direct asdf/system:proto-system :typeof clos:standard-class)
(:mop-direct asdf/system:proto-system :superclass common-lisp:standard-object)
(:mop-direct asdf/system:proto-system :slot ((:name asdf/component:name) (:ordinal 1)))
(:mop-direct asdf/system:proto-system :slot ((:name asdf/component:source-file) (:ordinal 2)))
(:mop-direct asdf/system:proto-system :slot
 ((:name asdf/system:definition-dependency-list) (:ordinal 3) (:readers (asdf/system:definition-dependency-list))
  (:writers ((common-lisp:setf asdf/system:definition-dependency-list)))))
(:mop-direct asdf/system:proto-system :slot
 ((:name asdf/system:definition-dependency-set) (:ordinal 4) (:initform (uiop/utility:list-to-hash-set common-lisp:nil))
  (:readers (asdf/system:definition-dependency-set)) (:writers ((common-lisp:setf asdf/system:definition-dependency-set)))))
(:mop-direct asdf/system:system :superclass asdf/component:module)
(:mop-direct asdf/system:system :superclass asdf/system:proto-system)
(:mop-direct asdf/package-inferred-system:package-inferred-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:prebuilt-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:precompiled-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:program-system :superclass asdf/system:system)
(:mop-direct asdf/operate:require-system :superclass asdf/system:system)
(:mop-direct asdf/system:undefined-system :superclass asdf/system:system)
(:mop-direct asdf/system:system :package-name "ASDF/SYSTEM")
(:mop-direct asdf/system:system :precedance
 (asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component asdf/system:proto-system
  common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/system:system :classof clos:standard-class)
(:mop-direct asdf/system:system :typeof clos:standard-class)
(:mop-direct asdf/system:system :superclass asdf/system:proto-system)
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:description) (:ordinal 1) (:readers (asdf/system:system-description))
  (:writers ((common-lisp:setf asdf/system:system-description)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:long-description) (:ordinal 2) (:readers (asdf/system:system-long-description))
  (:writers ((common-lisp:setf asdf/system:system-long-description)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:author) (:ordinal 3) (:initargs (:author)) (:readers (asdf/system:system-author))
  (:writers ((common-lisp:setf asdf/system:system-author)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:maintainer) (:ordinal 4) (:initargs (:maintainer)) (:readers (asdf/system:system-maintainer))
  (:writers ((common-lisp:setf asdf/system:system-maintainer)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:licence) (:ordinal 5) (:initargs (:licence :license)) (:readers (asdf/system:system-licence asdf/system:system-license))
  (:writers ((common-lisp:setf asdf/system:system-licence) (common-lisp:setf asdf/system:system-license)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:homepage) (:ordinal 6) (:initargs (:homepage)) (:readers (asdf/system:system-homepage))
  (:writers ((common-lisp:setf asdf/system:system-homepage)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:bug-tracker) (:ordinal 7) (:initargs (:bug-tracker)) (:readers (asdf/system:system-bug-tracker))
  (:writers ((common-lisp:setf asdf/system:system-bug-tracker)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:mailto) (:ordinal 8) (:initargs (:mailto)) (:readers (asdf/system:system-mailto))
  (:writers ((common-lisp:setf asdf/system:system-mailto)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:long-name) (:ordinal 9) (:initargs (:long-name)) (:readers (asdf/system:system-long-name))
  (:writers ((common-lisp:setf asdf/system:system-long-name)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:source-control) (:ordinal 10) (:initargs (:source-control)) (:readers (asdf/system:system-source-control))
  (:writers ((common-lisp:setf asdf/system:system-source-control)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:builtin-system-p) (:ordinal 11) (:initargs (:builtin-system-p)) (:readers (asdf/system:builtin-system-p))
  (:writers ((common-lisp:setf asdf/system:builtin-system-p)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:build-pathname) (:ordinal 12) (:initargs (:build-pathname)) (:readers (asdf/system:component-build-pathname))
  (:writers ((common-lisp:setf asdf/system:component-build-pathname)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/system:entry-point) (:ordinal 13) (:initargs (:entry-point)) (:readers (asdf/system:component-entry-point))
  (:writers ((common-lisp:setf asdf/system:component-entry-point)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:source-file) (:ordinal 14) (:initargs (:source-file)) (:readers (asdf/system:system-source-file))
  (:writers ((common-lisp:setf asdf/system:system-source-file)))))
(:mop-direct asdf/system:system :slot
 ((:name asdf/component:defsystem-depends-on) (:ordinal 15) (:initargs (:defsystem-depends-on))
  (:readers (asdf/system:system-defsystem-depends-on))))
(:mop-direct asdf/system:system :slot ((:name asdf/system::depends-on) (:ordinal 16) (:readers (asdf/system:system-depends-on))))
(:mop-direct asdf/system:system :slot ((:name asdf/system::weakly-depends-on) (:ordinal 17) (:readers (asdf/system:system-weakly-depends-on))))
(:mop-direct asdf/package-inferred-system:package-inferred-system :superclass asdf/system:system)
(:mop-direct asdf/package-inferred-system:package-system :superclass asdf/package-inferred-system:package-inferred-system)
(:mop-direct asdf/package-inferred-system:package-inferred-system :package-name "ASDF/PACKAGE-INFERRED-SYSTEM")
(:mop-direct asdf/package-inferred-system:package-inferred-system :precedance
 (asdf/system:system asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component
  asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/package-inferred-system:package-inferred-system :classof clos:standard-class)
(:mop-direct asdf/package-inferred-system:package-inferred-system :typeof clos:standard-class)
(:mop-direct asdf/package-inferred-system:package-inferred-system :superclass asdf/system:system)
(:mop-direct asdf/package-inferred-system:package-system :superclass asdf/package-inferred-system:package-inferred-system)
(:mop-direct asdf/package-inferred-system:package-system :package-name "ASDF/PACKAGE-INFERRED-SYSTEM")
(:mop-direct asdf/package-inferred-system:package-system :precedance
 (asdf/package-inferred-system:package-inferred-system asdf/system:system asdf/component:module asdf/component:child-component
  asdf/component:parent-component asdf/component:component asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/package-inferred-system:package-system :classof clos:standard-class)
(:mop-direct asdf/package-inferred-system:package-system :typeof clos:standard-class)
(:mop-direct asdf/package-inferred-system:package-system :superclass asdf/package-inferred-system:package-inferred-system)


(:mop-direct asdf/bundle:prebuilt-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:prebuilt-system :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:prebuilt-system :precedance
 (asdf/system:system asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component
  asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:prebuilt-system :classof clos:standard-class)
(:mop-direct asdf/bundle:prebuilt-system :typeof clos:standard-class)
(:mop-direct asdf/bundle:prebuilt-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:prebuilt-system :slot
 ((:name asdf/system:build-pathname) (:ordinal 1) (:initargs (:static-library :lib)) (:readers (asdf/bundle::prebuilt-system-static-library))
  (:writers ((common-lisp:setf asdf/bundle::prebuilt-system-static-library)))))

(:mop-direct asdf/bundle:precompiled-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:precompiled-system :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:precompiled-system :precedance
 (asdf/system:system asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component
  asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:precompiled-system :classof clos:standard-class)
(:mop-direct asdf/bundle:precompiled-system :typeof clos:standard-class)
(:mop-direct asdf/bundle:precompiled-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:precompiled-system :slot ((:name asdf/system:build-pathname) (:ordinal 1) (:initargs (:fasb :fasl))))

(:mop-direct asdf/bundle:program-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:program-system :package-name "ASDF/BUNDLE")
(:mop-direct asdf/bundle:program-system :precedance
 (asdf/system:system asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component
  asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/bundle:program-system :classof clos:standard-class)
(:mop-direct asdf/bundle:program-system :typeof clos:standard-class)
(:mop-direct asdf/bundle:program-system :superclass asdf/system:system)
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle:prologue-code) (:ordinal 1) (:initargs (:prologue-code)) (:readers (asdf/bundle:prologue-code))))
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle:epilogue-code) (:ordinal 2) (:initargs (:epilogue-code)) (:readers (asdf/bundle:epilogue-code))))
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle::no-uiop) (:ordinal 3) (:initargs (:no-uiop)) (:readers (asdf/bundle::no-uiop))))
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle::prefix-lisp-object-files) (:ordinal 4) (:initargs (:prefix-lisp-object-files))
  (:readers (asdf/bundle::prefix-lisp-object-files)) (:writers ((common-lisp:setf asdf/bundle::prefix-lisp-object-files)))))
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle::postfix-lisp-object-files) (:ordinal 5) (:initargs (:postfix-lisp-object-files))
  (:readers (asdf/bundle::postfix-lisp-object-files)) (:writers ((common-lisp:setf asdf/bundle::postfix-lisp-object-files)))))
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle::extra-object-files) (:ordinal 6) (:initargs (:extra-object-files)) (:readers (asdf/bundle::extra-object-files))
  (:writers ((common-lisp:setf asdf/bundle::extra-object-files)))))
(:mop-direct asdf/bundle:program-system :slot
 ((:name asdf/bundle::extra-build-args) (:ordinal 7) (:initargs (:extra-build-args)) (:readers (asdf/bundle::extra-build-args))
  (:writers ((common-lisp:setf asdf/bundle::extra-build-args)))))

(:mop-direct asdf/operate:require-system :superclass asdf/system:system)
(:mop-direct asdf/operate:require-system :package-name "ASDF/OPERATE")
(:mop-direct asdf/operate:require-system :precedance
 (asdf/system:system asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component
  asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/operate:require-system :classof clos:standard-class)
(:mop-direct asdf/operate:require-system :typeof clos:standard-class)
(:mop-direct asdf/operate:require-system :superclass asdf/system:system)
(:mop-direct asdf/operate:require-system :slot
 ((:name asdf/component:module) (:ordinal 1) (:initargs (:module)) (:readers (asdf/operate::required-module))
  (:writers ((common-lisp:setf asdf/operate::required-module)))))

(:mop-direct asdf/system:undefined-system :superclass asdf/system:system)
(:mop-direct asdf/system:undefined-system :package-name "ASDF/SYSTEM")
(:mop-direct asdf/system:undefined-system :precedance
 (asdf/system:system asdf/component:module asdf/component:child-component asdf/component:parent-component asdf/component:component
  asdf/system:proto-system common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/system:undefined-system :classof clos:standard-class)
(:mop-direct asdf/system:undefined-system :typeof clos:standard-class)
(:mop-direct asdf/system:undefined-system :superclass asdf/system:system)


(:mop-direct asdf/system:proto-system :prototype #<asdf/system:proto-system #x00033599F3D0>)
(:mop-direct asdf/session:forcing :superclass common-lisp:standard-object)
(:mop-direct asdf/session:forcing :package-name "ASDF/SESSION")
(:mop-direct asdf/session:forcing :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/session:forcing :classof clos:standard-class)
(:mop-direct asdf/session:forcing :typeof clos:standard-class)
(:mop-direct asdf/session:forcing :superclass common-lisp:standard-object)
(:mop-direct asdf/session:forcing :slot
 ((:name asdf/forcing:performable-p) (:ordinal 1) (:initargs (:performable-p)) (:readers (asdf/forcing:performable-p))))
(:mop-direct asdf/session:forcing :slot
 ((:name asdf/forcing::parameters) (:ordinal 2) (:initargs (:parameters)) (:readers (asdf/forcing::parameters))))
(:mop-direct asdf/session:forcing :slot ((:name asdf/forcing:forced) (:ordinal 3) (:initargs (:forced)) (:readers (asdf/forcing:forced))))
(:mop-direct asdf/session:forcing :slot
 ((:name asdf/forcing:forced-not) (:ordinal 4) (:initargs (:forced-not)) (:readers (asdf/forcing:forced-not))))

(:mop-direct asdf/plan:plan :superclass common-lisp:standard-object)
(:mop-direct asdf/plan:plan-traversal :superclass asdf/plan:plan)
(:mop-direct asdf/plan:plan :package-name "ASDF/PLAN")
(:mop-direct asdf/plan:plan :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/plan:plan :classof clos:standard-class)
(:mop-direct asdf/plan:plan :typeof clos:standard-class)
(:mop-direct asdf/plan:plan :superclass common-lisp:standard-object)
(:mop-direct asdf/plan:plan-traversal :superclass asdf/plan:plan)
(:mop-direct asdf/plan:sequential-plan :superclass asdf/plan:plan-traversal)
(:mop-direct asdf/plan:plan-traversal :package-name "ASDF/PLAN")
(:mop-direct asdf/plan:plan-traversal :precedance (asdf/plan:plan common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/plan:plan-traversal :classof clos:standard-class)
(:mop-direct asdf/plan:plan-traversal :typeof clos:standard-class)
(:mop-direct asdf/plan:plan-traversal :superclass asdf/plan:plan)
(:mop-direct asdf/plan:plan-traversal :slot
 ((:name asdf/session:forcing) (:ordinal 1) (:initform (asdf/session:forcing (asdf/session:toplevel-asdf-session))) (:initargs (:forcing))
  (:readers (asdf/session:forcing))))
(:mop-direct asdf/plan:sequential-plan :superclass asdf/plan:plan-traversal)
(:mop-direct asdf/plan:filtered-sequential-plan :superclass asdf/plan:sequential-plan)
(:mop-direct asdf/plan:sequential-plan :package-name "ASDF/PLAN")
(:mop-direct asdf/plan:sequential-plan :precedance (asdf/plan:plan-traversal asdf/plan:plan common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/plan:sequential-plan :classof clos:standard-class)
(:mop-direct asdf/plan:sequential-plan :typeof clos:standard-class)
(:mop-direct asdf/plan:sequential-plan :superclass asdf/plan:plan-traversal)
(:mop-direct asdf/plan:sequential-plan :slot
 ((:name asdf/plan::actions-r) (:ordinal 1) (:readers (asdf/plan:plan-actions-r)) (:writers ((common-lisp:setf asdf/plan:plan-actions-r)))))
(:mop-direct asdf/plan:filtered-sequential-plan :superclass asdf/plan:sequential-plan)
(:mop-direct asdf/plan:filtered-sequential-plan :package-name "ASDF/PLAN")
(:mop-direct asdf/plan:filtered-sequential-plan :precedance
 (asdf/plan:sequential-plan asdf/plan:plan-traversal asdf/plan:plan common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/plan:filtered-sequential-plan :classof clos:standard-class)
(:mop-direct asdf/plan:filtered-sequential-plan :typeof clos:standard-class)
(:mop-direct asdf/plan:filtered-sequential-plan :superclass asdf/plan:sequential-plan)
(:mop-direct asdf/plan:filtered-sequential-plan :slot
 ((:name asdf/plan::component-type) (:ordinal 1) (:initform common-lisp:t) (:initargs (:component-type))
  (:readers (asdf/plan:plan-component-type))))
(:mop-direct asdf/plan:filtered-sequential-plan :slot
 ((:name asdf/plan::keep-operation) (:ordinal 2) (:initform common-lisp:t) (:initargs (:keep-operation))
  (:readers (asdf/plan:plan-keep-operation))))
(:mop-direct asdf/plan:filtered-sequential-plan :slot
 ((:name asdf/plan::keep-component) (:ordinal 3) (:initform common-lisp:t) (:initargs (:keep-component))
  (:readers (asdf/plan:plan-keep-component))))
(:mop-direct asdf/plan:filtered-sequential-plan :prototype #<asdf/plan:filtered-sequential-plan #x0003359D2A30>)
(:mop-direct asdf/plan:sequential-plan :prototype #<asdf/plan:sequential-plan #x0003359D5850>)
(:mop-direct asdf/plan:plan-traversal :prototype #<asdf/plan:plan-traversal #x0003359D8188>)
(:mop-direct asdf/plan:plan :prototype #<asdf/plan:plan #x0003359DAAB8>)
(:mop-direct asdf/plan:action-status :superclass common-lisp:standard-object)
(:mop-direct asdf/plan:action-status :package-name "ASDF/PLAN")
(:mop-direct asdf/plan:action-status :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct asdf/plan:action-status :classof clos:standard-class)
(:mop-direct asdf/plan:action-status :typeof clos:standard-class)
(:mop-direct asdf/plan:action-status :superclass common-lisp:standard-object)
(:mop-direct asdf/plan:action-status :slot
 ((:name asdf/plan::bits) (:ordinal 1) (:type common-lisp:fixnum) (:initargs (:bits)) (:readers (asdf/plan::status-bits))))
(:mop-direct asdf/plan:action-status :slot
 ((:name asdf/plan::stamp) (:ordinal 2) (:type (common-lisp:or common-lisp:integer common-lisp:boolean)) (:initargs (:stamp))
  (:readers (asdf/plan:status-stamp))))
(:mop-direct asdf/plan:action-status :slot
 ((:name asdf/plan::level) (:ordinal 3) (:initform 0) (:type common-lisp:fixnum) (:initargs (:level)) (:readers (asdf/plan::status-level))))
(:mop-direct asdf/plan:action-status :slot
 ((:name asdf/plan::index) (:ordinal 4) (:type (common-lisp:or common-lisp:integer common-lisp:null)) (:initargs (:index))
  (:readers (asdf/plan:status-index))))

(:mop-direct qlqs-impl:lisp :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:lisp :package-name "QLQS-IMPL")
(:mop-direct qlqs-impl:lisp :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-impl:lisp :classof clos:standard-class)
(:mop-direct qlqs-impl:lisp :typeof clos:standard-class)
(:mop-direct qlqs-impl:lisp :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:lisp :prototype #<qlqs-impl:lisp #x0003359F5D80>)
(:mop-direct qlqs-impl:allegro :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:allegro :package-name "QLQS-IMPL")
(:mop-direct qlqs-impl:allegro :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-impl:allegro :classof clos:standard-class)
(:mop-direct qlqs-impl:allegro :typeof clos:standard-class)
(:mop-direct qlqs-impl:allegro :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:allegro :prototype #<qlqs-impl:allegro #x0003359FC148>)
(:mop-direct qlqs-impl:abcl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:abcl :package-name "QLQS-IMPL")
(:mop-direct qlqs-impl:abcl :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-impl:abcl :classof clos:standard-class)
(:mop-direct qlqs-impl:abcl :typeof clos:standard-class)
(:mop-direct qlqs-impl:abcl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:abcl :prototype #<qlqs-impl:abcl #x000335A02510>)
(:mop-direct qlqs-impl:ccl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:ccl :package-name "QLQS-IMPL")
(:mop-direct qlqs-impl:ccl :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-impl:ccl :classof clos:standard-class)
(:mop-direct qlqs-impl:ccl :typeof clos:standard-class)
(:mop-direct qlqs-impl:ccl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:ccl :prototype #<qlqs-impl:ccl #x000335A088D8>)
(:mop-direct qlqs-impl:clasp :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:clasp :package-name "QLQS-IMPL")
(:mop-direct qlqs-impl:clasp :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-impl:clasp :classof clos:standard-class)
(:mop-direct qlqs-impl:clasp :typeof clos:standard-class)
(:mop-direct qlqs-impl:clasp :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:clasp :prototype #<qlqs-impl:clasp #x000335A0ECA0>)
(:mop-direct qlqs-impl:clisp :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:clisp :package-name "QLQS-IMPL")
(:mop-direct qlqs-impl:clisp :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-impl:clisp :classof clos:standard-class)
(:mop-direct qlqs-impl:clisp :typeof clos:standard-class)
(:mop-direct qlqs-impl:clisp :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:clisp :prototype #<qlqs-impl:clisp #x000335A15068>)
(:mop-direct qlqs-impl:cmucl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:cmucl :package-name "QLQS-IMPL")
(:mop-direct qlqs-impl:cmucl :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-impl:cmucl :classof clos:standard-class)
(:mop-direct qlqs-impl:cmucl :typeof clos:standard-class)
(:mop-direct qlqs-impl:cmucl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:cmucl :prototype #<qlqs-impl:cmucl #x000335A1B430>)
(:mop-direct qlqs-impl:scl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:scl :package-name "QLQS-IMPL")
(:mop-direct qlqs-impl:scl :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-impl:scl :classof clos:standard-class)
(:mop-direct qlqs-impl:scl :typeof clos:standard-class)
(:mop-direct qlqs-impl:scl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:scl :prototype #<qlqs-impl:scl #x000335A217F8>)
(:mop-direct qlqs-impl:ecl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:ecl :package-name "QLQS-IMPL")
(:mop-direct qlqs-impl:ecl :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-impl:ecl :classof clos:standard-class)
(:mop-direct qlqs-impl:ecl :typeof clos:standard-class)
(:mop-direct qlqs-impl:ecl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:ecl :prototype #<qlqs-impl:ecl #x000335A27BC0>)
(:mop-direct qlqs-impl:lispworks :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:lispworks :package-name "QLQS-IMPL")
(:mop-direct qlqs-impl:lispworks :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-impl:lispworks :classof clos:standard-class)
(:mop-direct qlqs-impl:lispworks :typeof clos:standard-class)
(:mop-direct qlqs-impl:lispworks :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:lispworks :prototype #<qlqs-impl:lispworks #x000335A2DF88>)
(:mop-direct qlqs-impl:sbcl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:sbcl :package-name "QLQS-IMPL")
(:mop-direct qlqs-impl:sbcl :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-impl:sbcl :classof clos:standard-class)
(:mop-direct qlqs-impl:sbcl :typeof clos:standard-class)
(:mop-direct qlqs-impl:sbcl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:sbcl :prototype #<qlqs-impl:sbcl #x000335A34350>)
(:mop-direct qlqs-impl:mkcl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:mkcl :package-name "QLQS-IMPL")
(:mop-direct qlqs-impl:mkcl :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-impl:mkcl :classof clos:standard-class)
(:mop-direct qlqs-impl:mkcl :typeof clos:standard-class)
(:mop-direct qlqs-impl:mkcl :superclass common-lisp:standard-object)
(:mop-direct qlqs-impl:mkcl :prototype #<qlqs-impl:mkcl #x000335A3A718>)
(:mop-direct qlqs-progress::progress-bar :superclass common-lisp:standard-object)
(:mop-direct qlqs-progress::uncertain-size-progress-bar :superclass qlqs-progress::progress-bar)
(:mop-direct qlqs-progress::progress-bar :default-initargs
 ((:progress-character #\= #<compiled-function clos::constant-initfunction>)
  (:character-count 50 #<compiled-function clos::constant-initfunction>) (:characters-so-far 0 #<compiled-function clos::constant-initfunction>)
  (:update-interval (common-lisp:floor common-lisp:internal-time-units-per-second 4) #<compiled-function clos::constant-initfunction>)
  (:last-update-time 0 #<compiled-function clos::constant-initfunction>) (:total 0 #<compiled-function clos::constant-initfunction>)
  (:progress 0 #<compiled-function clos::constant-initfunction>) (:pending 0 #<compiled-function clos::constant-initfunction>)))
(:mop-direct qlqs-progress::progress-bar :package-name "QLQS-PROGRESS")
(:mop-direct qlqs-progress::progress-bar :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-progress::progress-bar :classof clos:standard-class)
(:mop-direct qlqs-progress::progress-bar :typeof clos:standard-class)
(:mop-direct qlqs-progress::progress-bar :superclass common-lisp:standard-object)
(:mop-direct qlqs-progress::progress-bar :slot
 ((:name qlqs-progress::start-time) (:ordinal 1) (:initargs (:start-time)) (:readers (qlqs-progress::start-time))
  (:writers ((common-lisp:setf qlqs-progress::start-time)))))
(:mop-direct qlqs-progress::progress-bar :slot
 ((:name qlqs-progress::end-time) (:ordinal 2) (:initargs (:end-time)) (:readers (qlqs-progress::end-time))
  (:writers ((common-lisp:setf qlqs-progress::end-time)))))
(:mop-direct qlqs-progress::progress-bar :slot
 ((:name qlqs-progress::progress-character) (:ordinal 3) (:initargs (:progress-character)) (:readers (qlqs-progress::progress-character))
  (:writers ((common-lisp:setf qlqs-progress::progress-character)))))
(:mop-direct qlqs-progress::progress-bar :slot
 ((:name qlqs-progress::character-count) (:ordinal 4) (:initargs (:character-count)) (:readers (qlqs-progress::character-count))
  (:writers ((common-lisp:setf qlqs-progress::character-count)))))
(:mop-direct qlqs-progress::progress-bar :slot
 ((:name qlqs-progress::characters-so-far) (:ordinal 5) (:initargs (:characters-so-far)) (:readers (qlqs-progress::characters-so-far))
  (:writers ((common-lisp:setf qlqs-progress::characters-so-far)))))
(:mop-direct qlqs-progress::progress-bar :slot
 ((:name qlqs-progress::update-interval) (:ordinal 6) (:initargs (:update-interval)) (:readers (qlqs-progress::update-interval))
  (:writers ((common-lisp:setf qlqs-progress::update-interval)))))
(:mop-direct qlqs-progress::progress-bar :slot
 ((:name qlqs-progress::last-update-time) (:ordinal 7) (:initargs (:last-update-time)) (:readers (qlqs-progress::last-update-time))
  (:writers ((common-lisp:setf qlqs-progress::last-update-time)))))
(:mop-direct qlqs-progress::progress-bar :slot
 ((:name qlqs-progress::total) (:ordinal 8) (:initargs (:total)) (:readers (qlqs-progress::total))
  (:writers ((common-lisp:setf qlqs-progress::total)))))
(:mop-direct qlqs-progress::progress-bar :slot
 ((:name qlqs-progress::progress) (:ordinal 9) (:initargs (:progress)) (:readers (qlqs-progress::progress))
  (:writers ((common-lisp:setf qlqs-progress::progress)))))
(:mop-direct qlqs-progress::progress-bar :slot
 ((:name qlqs-progress::pending) (:ordinal 10) (:initargs (:pending)) (:readers (qlqs-progress::pending))
  (:writers ((common-lisp:setf qlqs-progress::pending)))))
(:mop-direct qlqs-progress::uncertain-size-progress-bar :superclass qlqs-progress::progress-bar)
(:mop-direct qlqs-progress::uncertain-size-progress-bar :default-initargs
 ((:total 0 #<compiled-function clos::constant-initfunction>) (:progress-char-index 0 #<compiled-function clos::constant-initfunction>)
  (:units-per-char (common-lisp:floor (common-lisp:expt 1024 2) 50)
   #<function qlqs-progress::default-units-per-char common-lisp:nil (common-lisp:floor (common-lisp:expt 1024 2) 50)>)
  (:progress-character #\= #<compiled-function clos::constant-initfunction>)
  (:character-count 50 #<compiled-function clos::constant-initfunction>) (:characters-so-far 0 #<compiled-function clos::constant-initfunction>)
  (:update-interval (common-lisp:floor common-lisp:internal-time-units-per-second 4) #<compiled-function clos::constant-initfunction>)
  (:last-update-time 0 #<compiled-function clos::constant-initfunction>) (:progress 0 #<compiled-function clos::constant-initfunction>)
  (:pending 0 #<compiled-function clos::constant-initfunction>)))
(:mop-direct qlqs-progress::uncertain-size-progress-bar :package-name "QLQS-PROGRESS")
(:mop-direct qlqs-progress::uncertain-size-progress-bar :precedance (qlqs-progress::progress-bar common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-progress::uncertain-size-progress-bar :classof clos:standard-class)
(:mop-direct qlqs-progress::uncertain-size-progress-bar :typeof clos:standard-class)
(:mop-direct qlqs-progress::uncertain-size-progress-bar :superclass qlqs-progress::progress-bar)
(:mop-direct qlqs-progress::uncertain-size-progress-bar :slot
 ((:name qlqs-progress::progress-char-index) (:ordinal 1) (:initargs (:progress-char-index)) (:readers (qlqs-progress::progress-char-index))
  (:writers ((common-lisp:setf qlqs-progress::progress-char-index)))))
(:mop-direct qlqs-progress::uncertain-size-progress-bar :slot
 ((:name qlqs-progress::units-per-char) (:ordinal 2) (:initargs (:units-per-char)) (:readers (qlqs-progress::units-per-char))
  (:writers ((common-lisp:setf qlqs-progress::units-per-char)))))
(:mop-direct qlqs-progress::uncertain-size-progress-bar :prototype #<qlqs-progress::uncertain-size-progress-bar #x000335A73D88>)
(:mop-direct qlqs-progress::progress-bar :prototype #<qlqs-progress::progress-bar #x000335A76BE0>)
(:mop-direct qlqs-http::matcher :superclass common-lisp:standard-object)
(:mop-direct qlqs-http::matcher :package-name "QLQS-HTTP")
(:mop-direct qlqs-http::matcher :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-http::matcher :classof clos:standard-class)
(:mop-direct qlqs-http::matcher :typeof clos:standard-class)
(:mop-direct qlqs-http::matcher :superclass common-lisp:standard-object)
(:mop-direct qlqs-http::matcher :slot ((:name qlqs-http::pattern) (:ordinal 1) (:initargs (:pattern)) (:readers (qlqs-http::pattern))))
(:mop-direct qlqs-http::matcher :slot
 ((:name qlqs-http::pos) (:ordinal 2) (:initform 0) (:readers (qlqs-http::match-pos)) (:writers ((common-lisp:setf qlqs-http::match-pos)))))
(:mop-direct qlqs-http::matcher :slot
 ((:name qlqs-http::matchedp) (:ordinal 3) (:readers (qlqs-http::matchedp)) (:writers ((common-lisp:setf qlqs-http::matchedp)))))
(:mop-direct qlqs-http::matcher :prototype #<qlqs-http::matcher #x000335A83BF8>)
(:mop-direct qlqs-http::cbuf :superclass common-lisp:standard-object)
(:mop-direct qlqs-http::cbuf :default-initargs
 ((:data (qlqs-http::make-octet-vector qlqs-http::*cbuf-buffer-size*)
   #<function qlqs-http::default-data common-lisp:nil (qlqs-http::make-octet-vector qlqs-http::*cbuf-buffer-size*)>)
  (:connection common-lisp:nil #<compiled-function clos::constant-initfunction>) (:start 0 #<compiled-function clos::constant-initfunction>)
  (:end 0 #<compiled-function clos::constant-initfunction>) (:eofp common-lisp:nil #<compiled-function clos::constant-initfunction>)))
(:mop-direct qlqs-http::cbuf :package-name "QLQS-HTTP")
(:mop-direct qlqs-http::cbuf :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-http::cbuf :classof clos:standard-class)
(:mop-direct qlqs-http::cbuf :typeof clos:standard-class)
(:mop-direct qlqs-http::cbuf :superclass common-lisp:standard-object)
(:mop-direct qlqs-http::cbuf :slot
 ((:name qlqs-http::data) (:ordinal 1) (:initargs (:data)) (:readers (qlqs-http::data)) (:writers ((common-lisp:setf qlqs-http::data)))))
(:mop-direct qlqs-http::cbuf :slot
 ((:name qlqs-http::connection) (:ordinal 2) (:initargs (:connection)) (:readers (qlqs-http::connection))
  (:writers ((common-lisp:setf qlqs-http::connection)))))
(:mop-direct qlqs-http::cbuf :slot
 ((:name qlqs-http::start) (:ordinal 3) (:initargs (:start)) (:readers (qlqs-http::start)) (:writers ((common-lisp:setf qlqs-http::start)))))
(:mop-direct qlqs-http::cbuf :slot
 ((:name qlqs-http::end) (:ordinal 4) (:initargs (:end)) (:readers (qlqs-http::end)) (:writers ((common-lisp:setf qlqs-http::end)))))
(:mop-direct qlqs-http::cbuf :slot
 ((:name qlqs-http::eofp) (:ordinal 5) (:initargs (:eofp)) (:readers (qlqs-http::eofp)) (:writers ((common-lisp:setf qlqs-http::eofp)))))
(:mop-direct qlqs-http::cbuf :prototype #<qlqs-http::cbuf #x000335A9BA18>)
(:mop-direct qlqs-http::octet-sink :superclass common-lisp:standard-object)
(:mop-direct qlqs-http::octet-sink :default-initargs
 ((:storage (common-lisp:make-array 1024 :element-type 'qlqs-http::octet :fill-pointer 0 :adjustable common-lisp:t)
   #<function qlqs-http::default-storage common-lisp:nil
     (common-lisp:make-array 1024 :element-type 'qlqs-http::octet :fill-pointer 0 :adjustable common-lisp:t)>)))
(:mop-direct qlqs-http::octet-sink :package-name "QLQS-HTTP")
(:mop-direct qlqs-http::octet-sink :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-http::octet-sink :classof clos:standard-class)
(:mop-direct qlqs-http::octet-sink :typeof clos:standard-class)
(:mop-direct qlqs-http::octet-sink :superclass common-lisp:standard-object)
(:mop-direct qlqs-http::octet-sink :slot
 ((:name qlqs-http::storage) (:ordinal 1) (:initargs (:storage)) (:readers (qlqs-http::storage))
  (:writers ((common-lisp:setf qlqs-http::storage)))))
(:mop-direct qlqs-http::octet-sink :prototype #<qlqs-http::octet-sink #x000335AA7CA8>)
(:mop-direct qlqs-http::header :superclass common-lisp:standard-object)
(:mop-direct qlqs-http::header :package-name "QLQS-HTTP")
(:mop-direct qlqs-http::header :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-http::header :classof clos:standard-class)
(:mop-direct qlqs-http::header :typeof clos:standard-class)
(:mop-direct qlqs-http::header :superclass common-lisp:standard-object)
(:mop-direct qlqs-http::header :slot
 ((:name qlqs-http::data) (:ordinal 1) (:initargs (:data)) (:readers (qlqs-http::data)) (:writers ((common-lisp:setf qlqs-http::data)))))
(:mop-direct qlqs-http::header :slot
 ((:name qlqs-http::status) (:ordinal 2) (:initargs (:status)) (:readers (qlqs-http::status))
  (:writers ((common-lisp:setf qlqs-http::status)))))
(:mop-direct qlqs-http::header :slot
 ((:name qlqs-http::name-starts) (:ordinal 3) (:initargs (:name-starts)) (:readers (qlqs-http::name-starts))
  (:writers ((common-lisp:setf qlqs-http::name-starts)))))
(:mop-direct qlqs-http::header :slot
 ((:name qlqs-http::name-ends) (:ordinal 4) (:initargs (:name-ends)) (:readers (qlqs-http::name-ends))
  (:writers ((common-lisp:setf qlqs-http::name-ends)))))
(:mop-direct qlqs-http::header :slot
 ((:name qlqs-http::value-starts) (:ordinal 5) (:initargs (:value-starts)) (:readers (qlqs-http::value-starts))
  (:writers ((common-lisp:setf qlqs-http::value-starts)))))
(:mop-direct qlqs-http::header :slot
 ((:name qlqs-http::value-ends) (:ordinal 6) (:initargs (:value-ends)) (:readers (qlqs-http::value-ends))
  (:writers ((common-lisp:setf qlqs-http::value-ends)))))

(:mop-direct qlqs-http::url :superclass common-lisp:standard-object)
(:mop-direct qlqs-http::url :package-name "QLQS-HTTP")
(:mop-direct qlqs-http::url :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct qlqs-http::url :classof clos:standard-class)
(:mop-direct qlqs-http::url :typeof clos:standard-class)
(:mop-direct qlqs-http::url :superclass common-lisp:standard-object)
(:mop-direct qlqs-http::url :slot
 ((:name qlqs-http::hostname) (:ordinal 1) (:initargs (:hostname)) (:readers (qlqs-http::hostname))
  (:writers ((common-lisp:setf qlqs-http::hostname)))))
(:mop-direct qlqs-http::url :slot
 ((:name qlqs-http::port) (:ordinal 2) (:initform 80) (:initargs (:port)) (:readers (qlqs-http::port))
  (:writers ((common-lisp:setf qlqs-http::port)))))
(:mop-direct qlqs-http::url :slot
 ((:name qlqs-http::path) (:ordinal 3) (:initform "/") (:initargs (:path)) (:readers (qlqs-http::path))
  (:writers ((common-lisp:setf qlqs-http::path)))))

(:mop-direct quicklisp-quickstart::client-info :superclass common-lisp:standard-object)
(:mop-direct quicklisp-quickstart::client-info :package-name "QUICKLISP-QUICKSTART")
(:mop-direct quicklisp-quickstart::client-info :precedance (common-lisp:standard-object common-lisp:t))
(:mop-direct quicklisp-quickstart::client-info :classof clos:standard-class)
(:mop-direct quicklisp-quickstart::client-info :typeof clos:standard-class)
(:mop-direct quicklisp-quickstart::client-info :superclass common-lisp:standard-object)
(:mop-direct quicklisp-quickstart::client-info :slot
 ((:name quicklisp-quickstart::setup-url) (:ordinal 1) (:initargs (:setup-url)) (:readers (quicklisp-quickstart::setup-url))))
(:mop-direct quicklisp-quickstart::client-info :slot
 ((:name quicklisp-quickstart::asdf-url) (:ordinal 2) (:initargs (:asdf-url)) (:readers (quicklisp-quickstart::asdf-url))))
(:mop-direct quicklisp-quickstart::client-info :slot
 ((:name quicklisp-quickstart::client-tar-url) (:ordinal 3) (:initargs (:client-tar-url)) (:readers (quicklisp-quickstart::client-tar-url))))
(:mop-direct quicklisp-quickstart::client-info :slot
 ((:name quicklisp-quickstart::version) (:ordinal 4) (:initargs (:version)) (:readers (quicklisp-quickstart::version))))
(:mop-direct quicklisp-quickstart::client-info :slot
 ((:name quicklisp-quickstart::plist) (:ordinal 5) (:initargs (:plist)) (:readers (quicklisp-quickstart::plist))))
(:mop-direct quicklisp-quickstart::client-info :slot
 ((:name quicklisp-quickstart::source-file) (:ordinal 6) (:initargs (:source-file)) (:readers (quicklisp-quickstart::source-file))))

(:mop-direct common-lisp:standard-object :prototype #<common-lisp:standard-object #x000335AF8188>)
(:mop-direct common-lisp:sequence :superclass common-lisp:t)
(:mop-direct common-lisp:vector :superclass common-lisp:sequence)
(:mop-direct common-lisp:list :superclass common-lisp:sequence)
(:mop-direct common-lisp:sequence :package-name "COMMON-LISP")
(:mop-direct common-lisp:sequence :classof clos:built-in-class)
(:mop-direct common-lisp:sequence :typeof clos:built-in-class)
(:mop-direct common-lisp:sequence :superclass common-lisp:t)
(:mop-direct common-lisp:vector :superclass common-lisp:array)
(:mop-direct common-lisp:vector :superclass common-lisp:sequence)
(:mop-direct common-lisp:string :superclass common-lisp:vector)
(:mop-direct common-lisp:bit-vector :superclass common-lisp:vector)
(:mop-direct common-lisp:vector :package-name "COMMON-LISP")
(:mop-direct common-lisp:vector :precedance (common-lisp:array common-lisp:sequence common-lisp:t))
(:mop-direct common-lisp:vector :classof clos:built-in-class)
(:mop-direct common-lisp:vector :typeof clos:built-in-class)
(:mop-direct common-lisp:vector :superclass common-lisp:sequence)
(:mop-direct common-lisp:string :superclass common-lisp:vector)
(:mop-direct common-lisp:string :package-name "COMMON-LISP")
(:mop-direct common-lisp:string :precedance (common-lisp:vector common-lisp:array common-lisp:sequence common-lisp:t))
(:mop-direct common-lisp:string :classof clos:built-in-class)
(:mop-direct common-lisp:string :typeof clos:built-in-class)
(:mop-direct common-lisp:string :superclass common-lisp:vector)
(:mop-direct common-lisp:string :prototype "")
(:mop-direct common-lisp:bit-vector :superclass common-lisp:vector)
(:mop-direct common-lisp:bit-vector :package-name "COMMON-LISP")
(:mop-direct common-lisp:bit-vector :precedance (common-lisp:vector common-lisp:array common-lisp:sequence common-lisp:t))
(:mop-direct common-lisp:bit-vector :classof clos:built-in-class)
(:mop-direct common-lisp:bit-vector :typeof clos:built-in-class)
(:mop-direct common-lisp:bit-vector :superclass common-lisp:vector)
(:mop-direct common-lisp:bit-vector :prototype #*)
(:mop-direct common-lisp:vector :prototype #())
(:mop-direct common-lisp:list :superclass common-lisp:sequence)
(:mop-direct common-lisp:null :superclass common-lisp:list)
(:mop-direct common-lisp:cons :superclass common-lisp:list)
(:mop-direct common-lisp:list :package-name "COMMON-LISP")
(:mop-direct common-lisp:list :precedance (common-lisp:sequence common-lisp:t))
(:mop-direct common-lisp:list :classof clos:built-in-class)
(:mop-direct common-lisp:list :typeof clos:built-in-class)
(:mop-direct common-lisp:list :superclass common-lisp:sequence)
(:mop-direct common-lisp:null :superclass common-lisp:symbol)
(:mop-direct common-lisp:null :superclass common-lisp:list)
(:mop-direct common-lisp:null :package-name "COMMON-LISP")
(:mop-direct common-lisp:null :precedance (common-lisp:symbol common-lisp:list common-lisp:sequence common-lisp:t))
(:mop-direct common-lisp:null :classof clos:built-in-class)
(:mop-direct common-lisp:null :typeof clos:built-in-class)
(:mop-direct common-lisp:null :superclass common-lisp:list)
(:mop-direct common-lisp:null :prototype common-lisp:nil)
(:mop-direct common-lisp:cons :superclass common-lisp:list)
(:mop-direct common-lisp:cons :package-name "COMMON-LISP")
(:mop-direct common-lisp:cons :precedance (common-lisp:list common-lisp:sequence common-lisp:t))
(:mop-direct common-lisp:cons :classof clos:built-in-class)
(:mop-direct common-lisp:cons :typeof clos:built-in-class)
(:mop-direct common-lisp:cons :superclass common-lisp:list)
(:mop-direct common-lisp:cons :prototype (common-lisp:t))
(:mop-direct common-lisp:list :prototype common-lisp:nil)
(:mop-direct common-lisp:sequence :prototype common-lisp:nil)
(:mop-direct common-lisp:array :superclass common-lisp:t)
(:mop-direct common-lisp:vector :superclass common-lisp:array)
(:mop-direct common-lisp:array :package-name "COMMON-LISP")
(:mop-direct common-lisp:array :classof clos:built-in-class)
(:mop-direct common-lisp:array :typeof clos:built-in-class)
(:mop-direct common-lisp:array :superclass common-lisp:t)
(:mop-direct common-lisp:vector :superclass common-lisp:array)
(:mop-direct common-lisp:vector :superclass common-lisp:sequence)
(:mop-direct common-lisp:string :superclass common-lisp:vector)
(:mop-direct common-lisp:bit-vector :superclass common-lisp:vector)
(:mop-direct common-lisp:vector :package-name "COMMON-LISP")
(:mop-direct common-lisp:vector :precedance (common-lisp:array common-lisp:sequence common-lisp:t))
(:mop-direct common-lisp:vector :classof clos:built-in-class)
(:mop-direct common-lisp:vector :typeof clos:built-in-class)
(:mop-direct common-lisp:vector :superclass common-lisp:array)
(:mop-direct common-lisp:string :superclass common-lisp:vector)
(:mop-direct common-lisp:string :package-name "COMMON-LISP")
(:mop-direct common-lisp:string :precedance (common-lisp:vector common-lisp:array common-lisp:sequence common-lisp:t))
(:mop-direct common-lisp:string :classof clos:built-in-class)
(:mop-direct common-lisp:string :typeof clos:built-in-class)
(:mop-direct common-lisp:string :superclass common-lisp:vector)
(:mop-direct common-lisp:string :prototype "")
(:mop-direct common-lisp:bit-vector :superclass common-lisp:vector)
(:mop-direct common-lisp:bit-vector :package-name "COMMON-LISP")
(:mop-direct common-lisp:bit-vector :precedance (common-lisp:vector common-lisp:array common-lisp:sequence common-lisp:t))
(:mop-direct common-lisp:bit-vector :classof clos:built-in-class)
(:mop-direct common-lisp:bit-vector :typeof clos:built-in-class)
(:mop-direct common-lisp:bit-vector :superclass common-lisp:vector)
(:mop-direct common-lisp:bit-vector :prototype #*)
(:mop-direct common-lisp:vector :prototype #())
(:mop-direct common-lisp:array :prototype #A(common-lisp:t (0 0) ()))
(:mop-direct common-lisp:number :superclass common-lisp:t)
(:mop-direct common-lisp:real :superclass common-lisp:number)
(:mop-direct common-lisp:complex :superclass common-lisp:number)
(:mop-direct common-lisp:number :package-name "COMMON-LISP")
(:mop-direct common-lisp:number :classof clos:built-in-class)
(:mop-direct common-lisp:number :typeof clos:built-in-class)
(:mop-direct common-lisp:number :superclass common-lisp:t)
(:mop-direct common-lisp:real :superclass common-lisp:number)
(:mop-direct common-lisp:rational :superclass common-lisp:real)
(:mop-direct common-lisp:float :superclass common-lisp:real)
(:mop-direct common-lisp:real :package-name "COMMON-LISP")
(:mop-direct common-lisp:real :precedance (common-lisp:number common-lisp:t))
(:mop-direct common-lisp:real :classof clos:built-in-class)
(:mop-direct common-lisp:real :typeof clos:built-in-class)
(:mop-direct common-lisp:real :superclass common-lisp:number)
(:mop-direct common-lisp:rational :superclass common-lisp:real)
(:mop-direct common-lisp:integer :superclass common-lisp:rational)
(:mop-direct common-lisp:ratio :superclass common-lisp:rational)
(:mop-direct common-lisp:rational :package-name "COMMON-LISP")
(:mop-direct common-lisp:rational :precedance (common-lisp:real common-lisp:number common-lisp:t))
(:mop-direct common-lisp:rational :classof clos:built-in-class)
(:mop-direct common-lisp:rational :typeof clos:built-in-class)
(:mop-direct common-lisp:rational :superclass common-lisp:real)
(:mop-direct common-lisp:integer :superclass common-lisp:rational)
(:mop-direct common-lisp:integer :package-name "COMMON-LISP")
(:mop-direct common-lisp:integer :precedance (common-lisp:rational common-lisp:real common-lisp:number common-lisp:t))
(:mop-direct common-lisp:integer :classof clos:built-in-class)
(:mop-direct common-lisp:integer :typeof clos:built-in-class)
(:mop-direct common-lisp:integer :superclass common-lisp:rational)
(:mop-direct common-lisp:integer :prototype 0)
(:mop-direct common-lisp:ratio :superclass common-lisp:rational)
(:mop-direct common-lisp:ratio :package-name "COMMON-LISP")
(:mop-direct common-lisp:ratio :precedance (common-lisp:rational common-lisp:real common-lisp:number common-lisp:t))
(:mop-direct common-lisp:ratio :classof clos:built-in-class)
(:mop-direct common-lisp:ratio :typeof clos:built-in-class)
(:mop-direct common-lisp:ratio :superclass common-lisp:rational)
(:mop-direct common-lisp:ratio :prototype 1/2)
(:mop-direct common-lisp:rational :prototype common-lisp:nil)
(:mop-direct common-lisp:float :superclass common-lisp:real)
(:mop-direct common-lisp:float :package-name "COMMON-LISP")
(:mop-direct common-lisp:float :precedance (common-lisp:real common-lisp:number common-lisp:t))
(:mop-direct common-lisp:float :classof clos:built-in-class)
(:mop-direct common-lisp:float :typeof clos:built-in-class)
(:mop-direct common-lisp:float :superclass common-lisp:real)
(:mop-direct common-lisp:float :prototype 1.0s0)
(:mop-direct common-lisp:real :prototype common-lisp:nil)
(:mop-direct common-lisp:complex :superclass common-lisp:number)
(:mop-direct common-lisp:complex :package-name "COMMON-LISP")
(:mop-direct common-lisp:complex :precedance (common-lisp:number common-lisp:t))
(:mop-direct common-lisp:complex :classof clos:built-in-class)
(:mop-direct common-lisp:complex :typeof clos:built-in-class)
(:mop-direct common-lisp:complex :superclass common-lisp:number)
(:mop-direct common-lisp:complex :prototype #C(3 4))
(:mop-direct common-lisp:number :prototype common-lisp:nil)
(:mop-direct common-lisp:t :prototype #S(common-lisp:byte :size 1 :position 0))

|#