racer

SBCL 1.4.12.120-6b7a9a7 / ASDF 3.3.1

racer

WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/portableaserve/52bf14f263411e743de4007909a92165045fa5a3/portableaserve-20181201-git/aserve/aserve.asd" contains definition for system "aserve-test". Please only define "aserve" and secondary systems with a name starting with "aserve/" (e.g. "aserve/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/puri/79053c86ebabe7ec8aab7ef175e13c9f3a9f0960/puri-20181201-git/puri.asd" contains definition for system "puri-tests". Please only define "puri" and secondary systems with a name starting with "puri/" (e.g. "puri/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-ppcre/303f5a11b3d38e3d07c5da54d8f8bdba573c9460/cl-ppcre-20181201-git/cl-ppcre.asd" contains definition for system "cl-ppcre-test". Please only define "cl-ppcre" and secondary systems with a name starting with "cl-ppcre/" (e.g. "cl-ppcre/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-fad/e389592fd6c0af849f4f420657cd784036c44bc5/cl-fad-20181201-git/cl-fad.asd" contains definition for system "cl-fad-test". Please only define "cl-fad" and secondary systems with a name starting with "cl-fad/" (e.g. "cl-fad/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/flexi-streams/357a99b5a15e0607af668e4f7ad82eaf4cde82ec/flexi-streams-20181201-git/flexi-streams.asd" contains definition for system "flexi-streams-test". Please only define "flexi-streams" and secondary systems with a name starting with "flexi-streams/" (e.g. "flexi-streams/test") in that file.
WARNING: Reference to deprecated function (SB-THREAD:GET-MUTEX) from PROCESS-LOCK
STYLE-WARNING: Defining (*HEADER-BLOCK-SIZE*) as a constant, even though the name follows
the usual naming convention (names like *FOO*) for special variables
STYLE-WARNING: Defining (*HEADER-BLOCK-USED-SIZE-INDEX*) as a constant, even though the name follows
the usual naming convention (names like *FOO*) for special variables
STYLE-WARNING: Defining (*HEADER-BLOCK-DATA-START-INDEX*) as a constant, even though the name follows
the usual naming convention (names like *FOO*) for special variables
STYLE-WARNING: Defining (*HEADERS-COUNT*) as a constant, even though the name follows
the usual naming convention (names like *FOO*) for special variables
STYLE-WARNING: Defining (*BROWSER-LEVEL*) as a constant, even though the name follows
the usual naming convention (names like *FOO*) for special variables
WARNING: redefining COMMON-LISP:DEFCONSTANT in DEFMACRO

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer-persistence.lisp
; in: DEFUN READ-VALUE
;     (PERSISTENCE-MANAGER::READ-CODED-INTEGER STREAM)
; --> BLOCK LET LOOP BLOCK TAGBODY PROGN LET COND IF RETURN-FROM 
; ==>
;   'PERSISTENCE-MANAGER::EOF
; 
; caught STYLE-WARNING:
;   This is not a (MOD 1114112):
;    EOF
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer-persistence.lisp
; in: DEFUN CONSTRUCT-OBJECT
;     (PERSISTENCE-MANAGER::READ-CODED-INTEGER STREAM)
; --> BLOCK LET LOOP BLOCK TAGBODY PROGN LET COND IF RETURN-FROM 
; ==>
;   'PERSISTENCE-MANAGER::EOF
; 
; caught STYLE-WARNING:
;   This is not a REAL:
;    EOF
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; caught STYLE-WARNING:
;   This is not a REAL:
;    EOF
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer-persistence.lisp
; in: DECLAIM (INLINE STRUCTURE-INITIALIZER)
;     (DECLAIM (INLINE PERSISTENCE-MANAGER::STRUCTURE-INITIALIZER))
; --> EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE PERSISTENCE-MANAGER::STRUCTURE-INITIALIZER)
;                    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming PERSISTENCE-MANAGER::STRUCTURE-INITIALIZER to be INLINE, but 1 call to it was previously compiled. A declaration of NOTINLINE at the call site will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer-persistence.lisp
; in: DEFUN LOAD-PERSISTENT-OBJECT
;     (PERSISTENCE-MANAGER::READ-CODED-INTEGER STREAM)
; --> BLOCK LET LOOP BLOCK TAGBODY PROGN LET COND IF RETURN-FROM 
; ==>
;   'PERSISTENCE-MANAGER::EOF
; 
; caught STYLE-WARNING:
;   This is not a NUMBER:
;    EOF
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; caught STYLE-WARNING:
;   This is not a NUMBER:
;    EOF
;   See also:
;     The SBCL Manual, Node "Handling of Types"
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "racer" "persistence" "racer-persistence">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/http.lisp
; in: DEFUN SUBSTRING
;     (CHAR STRING WILBUR-RACER::R-INDEX)
; --> AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (CHAR-DOWNCASE WILBUR-RACER::C)
; 
; note: unable to open code due to type uncertainty: The first argument is a CHARACTER, not a BASE-CHAR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/http.lisp
; in: DEFUN COLLECT-TO-CHAR
;     (POSITION CHAR STRING :START WILBUR-RACER::START :END WILBUR-RACER::END :TEST
;               #'CHAR=)
; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%FIND-POSITION SB-C::ITEM SEQUENCE SB-C::FROM-END SB-C::START
;                             SB-C::END
;                             (SB-KERNEL:EFFECTIVE-FIND-POSITION-KEY SB-C::KEY)
;                             (SB-KERNEL:EFFECTIVE-FIND-POSITION-TEST SB-C::TEST
;                                                                     SB-C::TEST-NOT))
; 
; note: unable to expand inline because: upgraded array element type not known at compile time
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a CHARACTER.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/concept-structures.lisp
; in:
;      DEFSTRUCT (CONCEPT (:INCLUDE RACER-STRUCTURE-ID) (:CONSTRUCTOR MAKE-CONCEPT (TERM)) (:PREDICATE CONCEPT-P-INTERNAL))
;     (PERSISTENCE-MANAGER:DEFSTRUCT
;      (RACER::CONCEPT (:INCLUDE RACER::RACER-STRUCTURE-ID)
;       (:CONSTRUCTOR RACER::MAKE-CONCEPT (RACER::TERM))
;       (:PREDICATE RACER::CONCEPT-P-INTERNAL))
;      "Represents the common part of an encoded concept." (RACER::TERM NIL)
;      (RACER::MODEL NIL) (RACER::TOLD-SUBSUMERS NIL)
;      (RACER::NEGATED-CONCEPT-INTERNAL NIL) (RACER::LANGUAGE RACER::*DL-EMPTY*)
;      (RACER::TOLD-DISJOINTS NIL) (RACER::VISITED-MARK T) (RACER::REFERENCING NIL)
;      (RACER::FULL-REFERENCING NIL) ...)
; --> PERSISTENCE-MANAGER:DEFPERSISTENTSTRUCT PROGN DEFSTRUCT PROGN EVAL-WHEN 
; ==>
;   (SB-KERNEL::%COMPILER-DEFSTRUCT
;    '#<SB-KERNEL:DEFSTRUCT-DESCRIPTION RACER::CONCEPT {10051942F3}>
;    '#(#<SB-KERNEL:LAYOUT for T {50300003}>
;       #<SB-KERNEL:LAYOUT for STRUCTURE-OBJECT {50300083}>
;       #<SB-KERNEL:LAYOUT for PERSISTENCE-MANAGER::PERSISTENT-STRUCTURE {50544303}>
;       #<SB-KERNEL:LAYOUT for RACER::RACER-SET-ELEMENT {5055A383}>
;       #<SB-KERNEL:LAYOUT for RACER::RACER-STRUCTURE-ID {5055A583}>))
; 
; caught STYLE-WARNING:
;   Previously compiled call to RACER::CONCEPT-HASH-ID could not be inlined because the structure definition for RACER::CONCEPT was not yet seen. To avoid this warning, DEFSTRUCT should precede references to the affected functions, or they must be declared locally notinline at each call site.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "racer" "racer-kernel" "concept-structures">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/role-structures.lisp
; in:
;      DEFSTRUCT (ROLE-NODE (:INCLUDE RACER-STRUCTURE-ID) (:CONC-NAME ROLE-) (:PREDICATE ROLE-NODE-P))
;     (PERSISTENCE-MANAGER:DEFSTRUCT
;      (RACER::ROLE-NODE (:INCLUDE RACER::RACER-STRUCTURE-ID)
;       (:CONC-NAME RACER::ROLE-) (:PREDICATE RACER::ROLE-NODE-P))
;      "structure for an internal role or a feature" (RACER::NAME NIL)
;      (RACER:TRANSITIVE-P RACER:*ENCODE-ROLES-AS-TRANSITIVE*)
;      (RACER:REFLEXIVE-P RACER:*ENCODE-ROLES-AS-REFLEXIVE*)
;      (RACER::INVERSE-INTERNAL NIL) (RACER:FEATURE-P NIL)
;      (RACER::PARENTS-INTERNAL NIL) (RACER::CHILDREN-INTERNAL NIL)
;      (RACER::ANCESTORS-INTERNAL NIL) (RACER::HAS-ANCESTORS-P NIL) ...)
; --> PERSISTENCE-MANAGER:DEFPERSISTENTSTRUCT PROGN DEFSTRUCT PROGN EVAL-WHEN 
; ==>
;   (SB-KERNEL::%COMPILER-DEFSTRUCT
;    '#<SB-KERNEL:DEFSTRUCT-DESCRIPTION RACER::ROLE-NODE {100CAEC313}>
;    '#(#<SB-KERNEL:LAYOUT for T {50300003}>
;       #<SB-KERNEL:LAYOUT for STRUCTURE-OBJECT {50300083}>
;       #<SB-KERNEL:LAYOUT for PERSISTENCE-MANAGER::PERSISTENT-STRUCTURE {50544303}>
;       #<SB-KERNEL:LAYOUT for RACER::RACER-SET-ELEMENT {5055A383}>
;       #<SB-KERNEL:LAYOUT for RACER::RACER-STRUCTURE-ID {5055A583}>))
; 
; caught STYLE-WARNING:
;   Previously compiled calls to RACER::ROLE-NAME, RACER::ROLE-INVERSE-INTERNAL, RACER::ROLE-INTERNAL-CONJUNCTION-P, RACER::ROLE-INTERNAL-NAME-P, RACER::ROLE-CD-ATTRIBUTE and RACER::ROLE-DATATYPE could not be inlined because the structure definition for RACER::ROLE-NODE was not yet seen. To avoid this warning, DEFSTRUCT should precede references to the affected functions, or they must be declared locally notinline at each call site.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "racer" "racer-kernel" "role-structures">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/concrete-domains.lisp
; in: DEFSTRUCT (PREDICATE (:INCLUDE RACER-STRUCTURE-ID))
;     (PERSISTENCE-MANAGER:DEFSTRUCT
;      (RACER::PREDICATE (:INCLUDE RACER::RACER-STRUCTURE-ID)) (RACER::NAME NIL)
;      (RACER::DEFINITION NIL) (RACER::PARAMETERS NIL) (RACER::OPERATOR NIL)
;      (RACER::ARITY NIL) (RACER::NEGATION NIL) (TYPE NIL))
; --> PERSISTENCE-MANAGER:DEFPERSISTENTSTRUCT PROGN DEFSTRUCT PROGN EVAL-WHEN 
; ==>
;   (SB-KERNEL::%COMPILER-DEFSTRUCT
;    '#<SB-KERNEL:DEFSTRUCT-DESCRIPTION RACER::PREDICATE {100347A0A3}>
;    '#(#<SB-KERNEL:LAYOUT for T {50300003}>
;       #<SB-KERNEL:LAYOUT for STRUCTURE-OBJECT {50300083}>
;       #<SB-KERNEL:LAYOUT for PERSISTENCE-MANAGER::PERSISTENT-STRUCTURE {50544303}>
;       #<SB-KERNEL:LAYOUT for RACER::RACER-SET-ELEMENT {5055A383}>
;       #<SB-KERNEL:LAYOUT for RACER::RACER-STRUCTURE-ID {5055A583}>))
; 
; caught STYLE-WARNING:
;   Previously compiled call to RACER::PREDICATE-NAME could not be inlined because the structure definition for RACER::PREDICATE was not yet seen. To avoid this warning, DEFSTRUCT should precede references to the affected functions, or they must be declared locally notinline at each call site.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/concrete-domains.lisp
; in: DEFUN ADD-INTEGER-PREDICATE
;     (ERROR "concrete domain operator MIN or MAX expected in ~S."
;            RACER::DEFINITION)
; ==>
;   "concrete domain operator MIN or MAX expected in ~S."
; 
; note: deleting unreachable code
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "racer" "racer-kernel" "concrete-domains">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/kernel-state-structures.lisp
; in:
;      DEFSTRUCT (SIGNATURE-KERNEL-STATE (:CONC-NAME STATE-) (:INCLUDE BASIC-KERNEL-STATE) (:COPIER COPY-SIGNATURE-KERNEL-STATE-INTERNAL))
;     (PERSISTENCE-MANAGER:DEFSTRUCT
;      (RACER::SIGNATURE-KERNEL-STATE (:CONC-NAME RACER::STATE-)
;       (:INCLUDE RACER::BASIC-KERNEL-STATE)
;       (:COPIER RACER::COPY-SIGNATURE-KERNEL-STATE-INTERNAL))
;      (RACER::VIOLATED-ROLE NIL) (RACER::AT-MOST-CONSTRAINT NIL)
;      (RACER::TRUE-SOME-CONSTRAINTS NIL) (RACER::AT-LEAST-BOUNDS NIL)
;      (RACER::AT-MOST-BOUNDS NIL) (RACER::CURRENT-AT-MOST-BOUND NIL)
;      (RACER::REMAINING-AT-MOST-BOUNDS NIL)
;      (RACER::ROLE-RELATED-EXISTS-CONSTRAINTS NIL))
; --> PERSISTENCE-MANAGER:DEFPERSISTENTSTRUCT PROGN DEFSTRUCT PROGN EVAL-WHEN 
; ==>
;   (SB-KERNEL::%COMPILER-DEFSTRUCT
;    '#<SB-KERNEL:DEFSTRUCT-DESCRIPTION RACER::SIGNATURE-KERNEL-STATE {100C118FE3}>
;    '#(#<SB-KERNEL:LAYOUT for T {50300003}>
;       #<SB-KERNEL:LAYOUT for STRUCTURE-OBJECT {50300083}>
;       #<SB-KERNEL:LAYOUT for PERSISTENCE-MANAGER::PERSISTENT-STRUCTURE {50544303}>
;       #<SB-KERNEL:LAYOUT for RACER::BASIC-KERNEL-STATE {50568E83}>))
; 
; caught STYLE-WARNING:
;   Previously compiled call to RACER::SIGNATURE-KERNEL-STATE-P could not be inlined because the structure definition for RACER::SIGNATURE-KERNEL-STATE was not yet seen. To avoid this warning, DEFSTRUCT should precede references to the affected functions, or they must be declared locally notinline at each call site.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "racer" "racer-kernel" "kernel-state-structures">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox-structure.lisp
; in:
;      DEFSTRUCT (TBOX (:CONSTRUCTOR MAKE-TBOX-INTERNAL) (:COPIER COPY-TBOX-INTERNAL))
;     (PERSISTENCE-MANAGER:DEFSTRUCT
;      (RACER::TBOX (:CONSTRUCTOR RACER::MAKE-TBOX-INTERNAL)
;       (:COPIER RACER::COPY-TBOX-INTERNAL))
;      (RACER::NAME NIL) (RACER::IDENTIFICATION NIL)
;      (RACER::ORIGINAL-CONCEPT-AXIOMS NIL) (RACER::CONCEPT-AXIOMS NIL)
;      (RACER::CONCEPT-AXIOMS-INDEX NIL) (RACER::EXPECTED-CONCEPT-SIZE 100)
;      (RACER::EXPECTED-ROLE-SIZE 100) (RACER::GENERALIZED-CONCEPT-INCLUSIONS NIL)
;      (RACER::ADDED-GENERALIZED-CONCEPT-INCLUSIONS NIL)
;      (RACER::REMOVED-GENERALIZED-CONCEPT-INCLUSIONS NIL) ...)
; --> PERSISTENCE-MANAGER:DEFPERSISTENTSTRUCT PROGN DEFSTRUCT PROGN EVAL-WHEN 
; ==>
;   (SB-KERNEL::%COMPILER-DEFSTRUCT
;    '#<SB-KERNEL:DEFSTRUCT-DESCRIPTION RACER::TBOX {101032A8F3}>
;    '#(#<SB-KERNEL:LAYOUT for T {50300003}>
;       #<SB-KERNEL:LAYOUT for STRUCTURE-OBJECT {50300083}>
;       #<SB-KERNEL:LAYOUT for PERSISTENCE-MANAGER::PERSISTENT-STRUCTURE {50544303}>))
; 
; caught STYLE-WARNING:
;   Previously compiled calls to RACER::TBOX-TOP-NODE, RACER::TBOX-BOTTOM-NODE and RACER::TBOX-CONCRETE-DOMAIN could not be inlined because the structure definition for RACER::TBOX was not yet seen. To avoid this warning, DEFSTRUCT should precede references to the affected functions, or they must be declared locally notinline at each call site.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "racer" "racer-kernel" "tbox-structure">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/kernel-structures.lisp
; in:
;      DEFSTRUCT (OR-CONSTRAINT (:INCLUDE CONCEPT-CONSTRAINT) (:CONC-NAME CONSTRAINT-) (:CONSTRUCTOR MAKE-OR-CONSTRAINT-INTERNAL (IND TERM OR-CLAUSES-COUNTER OPEN-CLAUSES-COUNTER OR-CLAUSES-TRUTH-VALUE NEGATED-P)) (:COPIER COPY-OR-CONSTRAINT-INTERNAL))
;     (PERSISTENCE-MANAGER:DEFSTRUCT
;      (RACER::OR-CONSTRAINT (:INCLUDE RACER::CONCEPT-CONSTRAINT)
;       (:CONC-NAME RACER::CONSTRAINT-)
;       (:CONSTRUCTOR RACER::MAKE-OR-CONSTRAINT-INTERNAL
;        (RACER::IND RACER::TERM RACER::OR-CLAUSES-COUNTER
;         RACER::OPEN-CLAUSES-COUNTER RACER::OR-CLAUSES-TRUTH-VALUE
;         RACER::NEGATED-P))
;       (:COPIER RACER::COPY-OR-CONSTRAINT-INTERNAL))
;      "Represents an or-constraint as a specialized concept-constraint. Additionaly
;   records information about state and structure of or-constraints."
;      (RACER::OR-CLAUSES-COUNTER NIL) (RACER::OPEN-CLAUSES-COUNTER NIL)
;      (RACER::OTHER-OR-CLAUSES-DEPENDENCIES NIL)
;      (RACER::OR-CLAUSES-TRUTH-VALUE NIL))
; --> PERSISTENCE-MANAGER:DEFPERSISTENTSTRUCT PROGN DEFSTRUCT PROGN EVAL-WHEN 
; ==>
;   (SB-KERNEL::%COMPILER-DEFSTRUCT
;    '#<SB-KERNEL:DEFSTRUCT-DESCRIPTION RACER::OR-CONSTRAINT {100B85D003}>
;    '#(#<SB-KERNEL:LAYOUT for T {50300003}>
;       #<SB-KERNEL:LAYOUT for STRUCTURE-OBJECT {50300083}>
;       #<SB-KERNEL:LAYOUT for PERSISTENCE-MANAGER::PERSISTENT-STRUCTURE {50544303}>
;       #<SB-KERNEL:LAYOUT for RACER::RACER-SET-ELEMENT {5055A383}>
;       #<SB-KERNEL:LAYOUT for RACER::CONSTRAINT-COMMON {5056F203}>
;       #<SB-KERNEL:LAYOUT for RACER::CONCEPT-CONSTRAINT {5056F303}>))
; 
; caught STYLE-WARNING:
;   Previously compiled call to RACER::OR-CONSTRAINT-P could not be inlined because the structure definition for RACER::OR-CONSTRAINT was not yet seen. To avoid this warning, DEFSTRUCT should precede references to the affected functions, or they must be declared locally notinline at each call site.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/kernel-structures.lisp
; in: DEFMETHOD PRINT-OBJECT (RELATION-CONSTRAINT T)
;     (FORMAT STREAM "(~D(~S ~S) ~S)"
;             (RACER::CONSTRAINT-SUCCESSOR-COUNT RACER::OBJECT)
;             (RACER::CONSTRAINT-IND-1 RACER::OBJECT)
;             (RACER::CONSTRAINT-IND-2 RACER::OBJECT)
;             (RACER::CONSTRAINT-TERM RACER::OBJECT))
; ==>
;   STREAM
; 
; note: deleting unreachable code
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "racer" "racer-kernel" "kernel-structures">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer-utilities.lisp
; in: RACE-INLINE (SAFE-PERCENTAGE)
;     (RACER::RACE-INLINE (RACER::SAFE-PERCENTAGE))
; --> DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE RACER::SAFE-PERCENTAGE) (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::SAFE-PERCENTAGE to be INLINE, but 97 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer-utilities.lisp
; in: DEFUN CONCEPT-HASH
;     (SXHASH (RACER::RACER-STRUCTURE-ID-HASH-ID RACER::THING))
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a DOUBLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a FIXNUM.
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a SIMPLE-BIT-VECTOR.
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a SIMPLE-STRING.
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a SYMBOL.

;     (SXHASH RACER::THING)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (AND (NOT RACER-STRUCTURE-ID) ATOM), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (AND (NOT RACER-STRUCTURE-ID) ATOM), not a DOUBLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (AND (NOT RACER-STRUCTURE-ID) ATOM), not a FIXNUM.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (AND (NOT RACER-STRUCTURE-ID) ATOM), not a SIMPLE-BIT-VECTOR.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (AND (NOT RACER-STRUCTURE-ID) ATOM), not a SIMPLE-STRING.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (AND (NOT RACER-STRUCTURE-ID) ATOM), not a SYMBOL.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer-utilities.lisp
; in: DEFUN DISPOSE-HASH-TABLE
;     (RACER::ADD-TO-OBSOLETE-TABLES RACER::TABLE ':EQUAL-CONCEPT)
; ==>
;   RACER::TABLE
; 
; note: deleting unreachable code

; --> BLOCK LET RACER::RACER-WITHOUT-INTERRUPTS PROGN LET* WHEN IF PUSH LET* 
; ==>
;   RACER::TABLE
; 
; note: deleting unreachable code

; --> BLOCK LET RACER::RACER-WITHOUT-INTERRUPTS PROGN LET* HASH-TABLE-SIZE 
; ==>
;   RACER::TABLE
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer-utilities.lisp
; in: DEFUN SMART-CLRHASH
;     (HASH-TABLE-TEST HASH-TABLE)
; --> TRULY-THE SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   HASH-TABLE
; 
; note: deleting unreachable code

;     (RACER:RACER-MAKE-HASH-TABLE :TEST (HASH-TABLE-TEST HASH-TABLE) :SIZE
;      (MAX LENGTH 200) :STRUCTURE-P T)
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer-utilities.lisp
; in: RACE-INLINE (SET-EQUAL-P)
;     (RACER::RACE-INLINE (RACER::SET-EQUAL-P))
; --> DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE RACER::SET-EQUAL-P) (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::SET-EQUAL-P to be INLINE, but 4 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer-utilities.lisp
; in: DEFUN MAKE-CONSTRAINTS-TABLE
;     (RACER::MAKE-CONSTRAINTS-TABLE-KEY NRQL-SYMBOLS:CONSTRAINT)
; --> BLOCK COND IF LET* IF LOOP BLOCK LET RACER::CONSTRAINT-IND-SYNONYMS 
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   NRQL-SYMBOLS:CONSTRAINT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer-utilities.lisp
; in: DEFUN CONSTRAINT-FOUND-P
;     (RACER::MAKE-CONSTRAINTS-TABLE-KEY NRQL-SYMBOLS:CONSTRAINT)
; --> BLOCK COND IF LET* IF LOOP BLOCK LET RACER::CONSTRAINT-IND-SYNONYMS 
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   NRQL-SYMBOLS:CONSTRAINT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer-utilities.lisp
; in: DEFMACRO RACE-TIME
;     (DEFMACRO RACER::RACE-TIME (RACER::FORM &OPTIONAL (STRING NIL))
;       `(IF RACER::*SHOW-TIME*
;            (TIME ,RACER::FORM)
;            ,RACER::FORM))
; --> SB-INT:NAMED-DS-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G0
;           (SB-C::CHECK-DS-LIST (CDR #:EXPR) 1 2 '(# RACER::FORM &OPTIONAL #)))
;          (RACER::FORM (POP #:G0))
;          (STRING
;           (IF #:G0
;               (POP #:G0))))
;     (BLOCK RACER::RACE-TIME
;       `(IF RACER::*SHOW-TIME*
;            (TIME ,RACER::FORM)
;            ,RACER::FORM)))
; 
; caught STYLE-WARNING:
;   The variable STRING is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer-utilities.lisp
; in: DEFMACRO RACE-TIME
;     (DEFMACRO RACER::RACE-TIME (RACER::FORM &OPTIONAL (STRING NIL))
;       `(IF RACER::*SHOW-TIME*
;            (TIME ,RACER::FORM)
;            ,RACER::FORM))
; --> PROGN EVAL-WHEN SB-C::%DEFMACRO SB-C::%DEFMACRO SB-INT:NAMED-LAMBDA 
; --> FUNCTION SB-INT:NAMED-DS-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G0
;           (SB-C::CHECK-DS-LIST (CDR #:EXPR) 1 2 '(# RACER::FORM &OPTIONAL #)))
;          (RACER::FORM (POP #:G0))
;          (STRING
;           (IF #:G0
;               (POP #:G0))))
;     (BLOCK RACER::RACE-TIME
;       `(IF RACER::*SHOW-TIME*
;            (TIME ,RACER::FORM)
;            ,RACER::FORM)))
; 
; caught STYLE-WARNING:
;   The variable STRING is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "racer" "racer-kernel" "racer-utilities">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/constraint-store.lisp
; in: DEFUN REMOVE-INDIVIDUALS-FROM-CONSTRAINT-STORE
;     (RACER::SET-CONSTRAINT-STORE-ENTRY RACER::IND RACER::STORE RACER::NEW-TABLE
;      NIL)
; --> BLOCK IF SETF LET* 
; ==>
;   RACER::IND
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/models.lisp
; in:
;      DEFSTRUCT (FULL-MODEL-INFO (:CONC-NAME MODEL-) (:INCLUDE MODEL-INFO) (:CONSTRUCTOR MAKE-MODEL-INFO-TRULY-INTERNAL (CONCEPT BLOCKED-P EXISTS-MODELS DET-POSITIVE-LITERALS NON-DETERMINISTIC-P POSITIVE-LITERALS NEGATIVE-LITERALS RESTRICT-MODELS INDIVIDUAL LANGUAGE ATTRIBUTES ENSURED-ATTRIBUTES ...)))
;     (PERSISTENCE-MANAGER:DEFSTRUCT
;      (RACER::FULL-MODEL-INFO (:CONC-NAME RACER::MODEL-)
;       (:INCLUDE RACER::MODEL-INFO)
;       (:CONSTRUCTOR RACER::MAKE-MODEL-INFO-TRULY-INTERNAL
;        (RACER::CONCEPT RACER::BLOCKED-P RACER::EXISTS-MODELS
;         RACER::DET-POSITIVE-LITERALS RACER::NON-DETERMINISTIC-P
;         RACER::POSITIVE-LITERALS RACER::NEGATIVE-LITERALS RACER::RESTRICT-MODELS
;         RACER::INDIVIDUAL RACER::LANGUAGE RACER::ATTRIBUTES
;         RACER::ENSURED-ATTRIBUTES ...)))
;      (RACER::NON-DETERMINISTIC-P NIL) (RACER::POSITIVE-LITERALS NIL)
;      (RACER::NEGATIVE-LITERALS NIL) (RACER::RESTRICT-MODELS NIL)
;      (RACER::INDIVIDUAL NIL) (RACER::LANGUAGE RACER::*DL-EMPTY*)
;      (RACER::ATTRIBUTES NIL) (RACER::ENSURED-ATTRIBUTES NIL)
;      (RACER::DET-NEGATIVE-LITERALS NIL))
; --> PERSISTENCE-MANAGER:DEFPERSISTENTSTRUCT PROGN DEFSTRUCT PROGN EVAL-WHEN 
; ==>
;   (SB-KERNEL::%COMPILER-DEFSTRUCT
;    '#<SB-KERNEL:DEFSTRUCT-DESCRIPTION RACER::FULL-MODEL-INFO {10033E0433}>
;    '#(#<SB-KERNEL:LAYOUT for T {50300003}>
;       #<SB-KERNEL:LAYOUT for STRUCTURE-OBJECT {50300083}>
;       #<SB-KERNEL:LAYOUT for PERSISTENCE-MANAGER::PERSISTENT-STRUCTURE {50544303}>
;       #<SB-KERNEL:LAYOUT for RACER::MODEL-INFO {5057AE03}>))
; 
; caught STYLE-WARNING:
;   Previously compiled calls to RACER::FULL-MODEL-INFO-P and RACER::MODEL-NON-DETERMINISTIC-P could not be inlined because the structure definition for RACER::FULL-MODEL-INFO was not yet seen. To avoid this warning, DEFSTRUCT should precede references to the affected functions, or they must be declared locally notinline at each call site.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/models.lisp
; in: DEFUN MAKE-MODEL-COPY
;     (RACER::MODEL-CONCEPT RACER::SOURCE-MODEL)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::SOURCE-MODEL
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/models.lisp
; in: RACE-INLINE (INCOHERENT-MODEL-P)
;     (RACER::RACE-INLINE (RACER::INCOHERENT-MODEL-P))
; --> DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE RACER::INCOHERENT-MODEL-P) (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::INCOHERENT-MODEL-P to be INLINE, but 2 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/models.lisp
; in: RACE-INLINE (GET-CACHED-MODEL GET-CACHED-CONCEPT-MODEL)
;     (RACER::RACE-INLINE (RACER::GET-CACHED-MODEL RACER::GET-CACHED-CONCEPT-MODEL))
; --> DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM
;    '(INLINE RACER::GET-CACHED-MODEL RACER::GET-CACHED-CONCEPT-MODEL)
;    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::GET-CACHED-CONCEPT-MODEL to be INLINE, but 6 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/models.lisp
; in:
;      RACE-INLINE (COLLECT-CULPRIT-CONSTRAINTS CONTRAINT-CONCEPT-TERM-MODEL CONTRAINT-TERM-MODEL)
;     (RACER::RACE-INLINE
;      (RACER::COLLECT-CULPRIT-CONSTRAINTS RACER::CONTRAINT-CONCEPT-TERM-MODEL
;       RACER::CONTRAINT-TERM-MODEL))
; --> DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM
;    '(INLINE RACER::COLLECT-CULPRIT-CONSTRAINTS
;      RACER::CONTRAINT-CONCEPT-TERM-MODEL RACER::CONTRAINT-TERM-MODEL)
;    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::COLLECT-CULPRIT-CONSTRAINTS to be INLINE, but 1 call to it was previously compiled. A declaration of NOTINLINE at the call site will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/models.lisp
; in: DEFUN SUBMODELS-MERGABLE-P
;     (RACER::MODEL-NON-DETERMINISTIC-P RACER::SELECTED-MODEL)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::SELECTED-MODEL
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/models.lisp
; in: RACE-INLINE (UPDATE-MODEL-CLASH-CULPRITS)
;     (RACER::RACE-INLINE (RACER::UPDATE-MODEL-CLASH-CULPRITS))
; --> DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE RACER::UPDATE-MODEL-CLASH-CULPRITS)
;                    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::UPDATE-MODEL-CLASH-CULPRITS to be INLINE, but 1 call to it was previously compiled. A declaration of NOTINLINE at the call site will eliminate this warning, as will proclaiming and defining the function before its first potential use.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "racer" "racer-kernel" "models">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/subset-cache.lisp
; in: DEFUN INSERT-INTO-CACHE-1
;     (WHEN RACER::CACHE
;       (RACER::ADD-TO-NULL-MARKER RACER::CACHE RACER::VALUE RACER::SUPPLIED-P))
; --> IF 
; ==>
;   RACER::CACHE
; 
; note: deleting unreachable code

;     (RACER::ADD-TO-NULL-MARKER RACER::CACHE RACER::VALUE RACER::SUPPLIED-P)
; --> BLOCK IF 
; ==>
;   RACER::SUPPLIED-P
; 
; note: deleting unreachable code

; --> BLOCK IF IF RACER::CACHE-NULL-MARKER SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::CACHE
; 
; note: deleting unreachable code

; --> BLOCK IF IF PUSHNEW LET* RACER::CACHE-NULL-MARKER SB-KERNEL:%INSTANCE-REF 
; --> THE 
; ==>
;   RACER::CACHE
; 
; note: deleting unreachable code

; --> BLOCK IF IF SETF SB-KERNEL:%INSTANCE-SET THE 
; ==>
;   RACER::CACHE
; 
; note: deleting unreachable code

; --> BLOCK IF SETF SB-KERNEL:%INSTANCE-SET THE 
; ==>
;   RACER::CACHE
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/encoding.lisp
; in: RACE-INLINE (GET-ROLE (SETF GET-ROLE))
;     (RACER::RACE-INLINE (RACER::GET-ROLE (SETF RACER::GET-ROLE)))
; --> DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE RACER::GET-ROLE (SETF RACER::GET-ROLE))
;                    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::GET-ROLE to be INLINE, but 2 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/encoding.lisp
; in: DEFUN SET-LANGUAGE
;     (RACER::ADD-DL-FULL-DATATYPE-CONCRETE-DOMAINS RACER::NEW-LANGUAGE)
; ==>
;   RACER::NEW-LANGUAGE
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/encoding.lisp
; in: DEFUN REGISTER-NEW-CONCEPT-2
;     (LIST RACER::TYPE-TERM NUMBER RACER::ROLE RACER::ENCODED-TERM)
; ==>
;   RACER::TYPE-TERM
; 
; note: deleting unreachable code
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "racer" "racer-kernel" "encoding">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/signatures.lisp
; in:
;      DEFSTRUCT (QUALIFIED-ROLE-SIGNATURE (:INCLUDE RACER-SET-ELEMENT) (:CONC-NAME SIGNATURE-) (:CONSTRUCTOR MAKE-SIGNATURE (IND DEPENDENCIES ROLE &KEY (CONCEPTS NIL) (SUCCESSOR-IND-SET NIL) (CARDINALITY 1) (CONCEPT-DEPENDENCIES NIL) (GENERATING-EXISTS-CONSTRAINT NIL))))
;     (PERSISTENCE-MANAGER:DEFSTRUCT
;      (RACER::QUALIFIED-ROLE-SIGNATURE (:INCLUDE RACER::RACER-SET-ELEMENT)
;       (:CONC-NAME RACER::SIGNATURE-)
;       (:CONSTRUCTOR RACER::MAKE-SIGNATURE
;        (RACER::IND RACER::DEPENDENCIES RACER::ROLE &KEY (RACER::CONCEPTS NIL)
;         (RACER::SUCCESSOR-IND-SET NIL) (RACER::CARDINALITY 1)
;         (RACER::CONCEPT-DEPENDENCIES NIL)
;         (RACER::GENERATING-EXISTS-CONSTRAINT NIL))))
;      (RACER::DEPENDENCIES NIL) (RACER::ROLE NIL) (RACER::CONCEPTS NIL)
;      (RACER::IND NIL) (RACER::SUCCESSOR-IND-SET NIL) (RACER::CARDINALITY 1)
;      (RACER::OR-LEVEL RACER::*OR-LEVEL*) (RACER::CONCEPT-DEPENDENCIES NIL)
;      (RACER::GENERATING-EXISTS-CONSTRAINT NIL))
; --> PERSISTENCE-MANAGER:DEFPERSISTENTSTRUCT PROGN DEFSTRUCT PROGN EVAL-WHEN 
; ==>
;   (SB-KERNEL::%COMPILER-DEFSTRUCT
;    '#<SB-KERNEL:DEFSTRUCT-DESCRIPTION RACER::QUALIFIED-ROLE-SIGNATURE {1003043AD3}>
;    '#(#<SB-KERNEL:LAYOUT for T {50300003}>
;       #<SB-KERNEL:LAYOUT for STRUCTURE-OBJECT {50300083}>
;       #<SB-KERNEL:LAYOUT for PERSISTENCE-MANAGER::PERSISTENT-STRUCTURE {50544303}>
;       #<SB-KERNEL:LAYOUT for RACER::RACER-SET-ELEMENT {5055A383}>))
; 
; caught STYLE-WARNING:
;   Previously compiled calls to RACER::QUALIFIED-ROLE-SIGNATURE-P, RACER::SIGNATURE-DEPENDENCIES, RACER::SIGNATURE-ROLE, RACER::SIGNATURE-IND, RACER::SIGNATURE-SUCCESSOR-IND-SET and RACER::SIGNATURE-CONCEPT-DEPENDENCIES could not be inlined because the structure definition for RACER::QUALIFIED-ROLE-SIGNATURE was not yet seen. To avoid this warning, DEFSTRUCT should precede references to the affected functions, or they must be declared locally notinline at each call site.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/signatures.lisp
; in: DEFSTRUCT (NUMBER-RESTRICTION-BOUND (:CONC-NAME BOUND-))
;     (PERSISTENCE-MANAGER:DEFSTRUCT
;      (RACER::NUMBER-RESTRICTION-BOUND (:CONC-NAME RACER::BOUND-))
;      (RACER::ROLE NIL) (RACER::CONCEPT-LIST NIL)
;      (RACER::QUALIFICATION RACER::*TOP-CONCEPT*) (NUMBER NIL)
;      (NRQL-SYMBOLS:CONSTRAINT NIL))
; --> PERSISTENCE-MANAGER:DEFPERSISTENTSTRUCT PROGN DEFSTRUCT PROGN EVAL-WHEN 
; ==>
;   (SB-KERNEL::%COMPILER-DEFSTRUCT
;    '#<SB-KERNEL:DEFSTRUCT-DESCRIPTION RACER::NUMBER-RESTRICTION-BOUND {100ADF4B53}>
;    '#(#<SB-KERNEL:LAYOUT for T {50300003}>
;       #<SB-KERNEL:LAYOUT for STRUCTURE-OBJECT {50300083}>
;       #<SB-KERNEL:LAYOUT for PERSISTENCE-MANAGER::PERSISTENT-STRUCTURE {50544303}>))
; 
; caught STYLE-WARNING:
;   Previously compiled call to RACER::BOUND-ROLE could not be inlined because the structure definition for RACER::NUMBER-RESTRICTION-BOUND was not yet seen. To avoid this warning, DEFSTRUCT should precede references to the affected functions, or they must be declared locally notinline at each call site.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/signatures.lisp
; in: DEFUN MERGE-SIGNATURE-PAIR-1
;     (REST RACER::NEW-SIGNATURES)
; --> CDR 
; ==>
;   RACER::NEW-SIGNATURES
; 
; note: deleting unreachable code

;     (FIRST RACER::NEW-SIGNATURES)
; --> CAR 
; ==>
;   RACER::NEW-SIGNATURES
; 
; note: deleting unreachable code

;     (RACER::BOUND-NUMBER RACER::CURRENT-AT-MOST-BOUND)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::CURRENT-AT-MOST-BOUND
; 
; note: deleting unreachable code

;     (RACER::UPDATE-CATCHING-CLASH-DEPENDENCIES RACER::RELATED-SIGNATURES)
; ==>
;   RACER::RELATED-SIGNATURES
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/signatures.lisp
; in: DEFUN SPLIT-SIGNATURES
;     (RACER::ADDED-CONSTRAINTS-SATISFIABLE NIL NIL RACER::XSTATE T NIL)
; ==>
;   RACER::XSTATE
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/signatures.lisp
; in: DEFUN EXPANDED-EXISTS-PARTITIONS-SATISFIABLE-1
;     (VALUES RACER::NEW-UNEXPANDED-EXISTS-CONSTRAINTS
;             RACER::NEW-UNEXP-EXISTS-STORE)
; ==>
;   RACER::NEW-UNEXPANDED-EXISTS-CONSTRAINTS
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/signatures.lisp
; in: DEFUN EXPANDED-EXISTS-PARTITIONS-SATISFIABLE-2
;     (VALUES RACER::NEW-UNEXPANDED-EXISTS-CONSTRAINTS
;             RACER::NEW-UNEXP-EXISTS-STORE)
; ==>
;   RACER::NEW-UNEXPANDED-EXISTS-CONSTRAINTS
; 
; note: deleting unreachable code
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "racer" "racer-kernel" "signatures">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/cd-satisfiable.lisp
; in: DEFUN CONSTRAINT-SATISFIABLE-P-1
;     (SETF RACER::PRED NRQL-SYMBOLS:NEG)
; --> SETQ THE 
; ==>
;   NRQL-SYMBOLS:NEG
; 
; note: deleting unreachable code

;     (FORMAT T "~%testing satisfiability of constraint system:~%")
; ==>
;   "~%testing satisfiability of constraint system:~%"
; 
; note: deleting unreachable code

;     (AND RACER:STATE (REVERSE (RACER::SOLVER-STATE-CD-CONSTRAINTS RACER:STATE)))
; --> IF 
; ==>
;   RACER:STATE
; 
; note: deleting unreachable code

;     (RACER::CD-CONSTRAINT-PREDICATE RACER::CD-CONSTRAINT)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::CD-CONSTRAINT
; 
; note: deleting unreachable code

;     (FORMAT T "~A~%"
;             (IF (RACER::CD-CONSTRAINT-NEGATED-P RACER::CD-CONSTRAINT)
;                 (RACER::PREDICATE-NEGATION
;                  (RACER::CD-CONSTRAINT-PREDICATE RACER::CD-CONSTRAINT))
;                 (RACER::CD-CONSTRAINT-PREDICATE RACER::CD-CONSTRAINT)))
; 
; note: deleting unreachable code

; ==>
;   "~A~%"
; 
; note: deleting unreachable code

;     (RACER::CD-CONSTRAINT-PREDICATE RACER::CD-CONSTRAINT)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::CD-CONSTRAINT
; 
; note: deleting unreachable code

;     (RACER::SOLVER-STATE-CD-CONSTRAINTS RACER:STATE)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER:STATE
; 
; note: deleting unreachable code

;     (LIST NRQL-SYMBOLS:CONSTRAINT)
; --> CONS 
; ==>
;   NRQL-SYMBOLS:CONSTRAINT
; 
; note: deleting unreachable code

;     (FORMAT T "~A~%" RACER::PRED)
; ==>
;   "~A~%"
; 
; note: deleting unreachable code

;     (VALUES NIL "Unknown predicate: " RACER::PRED-NAME)
; ==>
;   "Unknown predicate: "
; 
; note: deleting unreachable code

;     (ERROR "Cannot handle this constraint ~S." NRQL-SYMBOLS:CONSTRAINT)
; ==>
;   "Cannot handle this constraint ~S."
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer.lisp
; in: RACE-INLINE (SUBSUMES-CONCEPT-P CONCEPT-CLASH-P)
;     (RACER::RACE-INLINE (RACER::SUBSUMES-CONCEPT-P RACER::CONCEPT-CLASH-P))
; --> DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE RACER::SUBSUMES-CONCEPT-P RACER::CONCEPT-CLASH-P)
;                    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::SUBSUMES-CONCEPT-P to be INLINE, but 2 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::CONCEPT-CLASH-P to be INLINE, but 10 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer.lisp
; in:
;      RACE-INLINE (NEW-ROOT-CONCEPT-CONSTRAINT NEW-INITIAL-CONCEPT-CONSTRAINT NEW-RELATION-CONSTRAINT OR-CLAUSE-TRUTH-VALUE SET-OR-CLAUSE-TRUTH-VALUE OPEN-OR-CLAUSE-P)
;     (RACER::RACE-INLINE
;      (RACER::NEW-ROOT-CONCEPT-CONSTRAINT RACER::NEW-INITIAL-CONCEPT-CONSTRAINT
;       RACER::NEW-RELATION-CONSTRAINT RACER::OR-CLAUSE-TRUTH-VALUE
;       RACER::SET-OR-CLAUSE-TRUTH-VALUE RACER::OPEN-OR-CLAUSE-P))
; --> DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM
;    '(INLINE RACER::NEW-ROOT-CONCEPT-CONSTRAINT
;      RACER::NEW-INITIAL-CONCEPT-CONSTRAINT RACER::NEW-RELATION-CONSTRAINT
;      RACER::OR-CLAUSE-TRUTH-VALUE RACER::SET-OR-CLAUSE-TRUTH-VALUE
;      RACER::OPEN-OR-CLAUSE-P)
;    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::NEW-INITIAL-CONCEPT-CONSTRAINT to be INLINE, but 1 call to it was previously compiled. A declaration of NOTINLINE at the call site will eliminate this warning, as will proclaiming and defining the function before its first potential use.
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::SET-OR-CLAUSE-TRUTH-VALUE to be INLINE, but 2 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer.lisp
; in: DEFUN DISTRIBUTE-NEW-CONSTRAINTS-2-3
;     (RACER::CONSTRAINT-FOUND-P NRQL-SYMBOLS:CONSTRAINT RACER::TABLE)
; --> BLOCK GETHASH SB-IMPL::GETHASH3 RACER::MAKE-CONSTRAINTS-TABLE-KEY BLOCK 
; --> COND IF LET* IF LOOP BLOCK LET RACER::CONSTRAINT-IND-SYNONYMS 
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   NRQL-SYMBOLS:CONSTRAINT
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

; --> BLOCK GETHASH SB-IMPL::GETHASH3 RACER::MAKE-CONSTRAINTS-TABLE-KEY BLOCK 
; --> COND IF IF RACER::RELATION-CONSTRAINT-P SB-C::%INSTANCE-TYPEP 
; ==>
;   NRQL-SYMBOLS:CONSTRAINT
; 
; note: deleting unreachable code

; --> BLOCK GETHASH SB-IMPL::GETHASH3 RACER::MAKE-CONSTRAINTS-TABLE-KEY BLOCK 
; --> COND IF IF IF LIST RACER::SIGNATURE-SUCCESSOR-IND-SET 
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   NRQL-SYMBOLS:CONSTRAINT
; 
; note: deleting unreachable code

; --> BLOCK GETHASH SB-IMPL::GETHASH3 RACER::MAKE-CONSTRAINTS-TABLE-KEY BLOCK 
; --> COND IF IF LIST RACER::CONSTRAINT-IND-2 SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   NRQL-SYMBOLS:CONSTRAINT
; 
; note: deleting unreachable code

; --> BLOCK GETHASH SB-IMPL::GETHASH3 RACER::MAKE-CONSTRAINTS-TABLE-KEY BLOCK 
; --> COND IF IF IF LIST RACER::SIGNATURE-SUCCESSOR-IND-SET 
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   NRQL-SYMBOLS:CONSTRAINT
; 
; note: deleting unreachable code

; --> BLOCK GETHASH SB-IMPL::GETHASH3 RACER::MAKE-CONSTRAINTS-TABLE-KEY BLOCK 
; --> COND IF IF LIST RACER::CONSTRAINT-IND-2 SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   NRQL-SYMBOLS:CONSTRAINT
; 
; note: deleting unreachable code

; --> BLOCK GETHASH SB-IMPL::GETHASH3 RACER::MAKE-CONSTRAINTS-TABLE-KEY BLOCK 
; --> COND IF IF LIST RACER::CONSTRAINT-IND-1 SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   NRQL-SYMBOLS:CONSTRAINT
; 
; note: deleting unreachable code

; --> BLOCK GETHASH SB-IMPL::GETHASH3 RACER::MAKE-CONSTRAINTS-TABLE-KEY BLOCK 
; --> COND IF IF IF RACER::QUALIFIED-ROLE-SIGNATURE-P SB-C::%INSTANCE-TYPEP 
; ==>
;   NRQL-SYMBOLS:CONSTRAINT
; 
; note: deleting unreachable code

; --> BLOCK GETHASH SB-IMPL::GETHASH3 RACER::MAKE-CONSTRAINTS-TABLE-KEY BLOCK 
; --> COND IF IF IF LIST RACER::SIGNATURE-IND SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   NRQL-SYMBOLS:CONSTRAINT
; 
; note: deleting unreachable code

; --> BLOCK GETHASH SB-IMPL::GETHASH3 RACER::MAKE-CONSTRAINTS-TABLE-KEY BLOCK 
; --> COND IF IF RACER::RELATION-CONSTRAINT-P SB-C::%INSTANCE-TYPEP 
; ==>
;   NRQL-SYMBOLS:CONSTRAINT
; 
; note: deleting unreachable code

; --> BLOCK GETHASH SB-IMPL::GETHASH3 RACER::MAKE-CONSTRAINTS-TABLE-KEY BLOCK 
; --> COND IF IF LIST RACER::CONSTRAINT-IND-1 SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   NRQL-SYMBOLS:CONSTRAINT
; 
; note: deleting unreachable code

; --> BLOCK GETHASH SB-IMPL::GETHASH3 RACER::MAKE-CONSTRAINTS-TABLE-KEY BLOCK 
; --> COND IF IF IF RACER::QUALIFIED-ROLE-SIGNATURE-P SB-C::%INSTANCE-TYPEP 
; ==>
;   NRQL-SYMBOLS:CONSTRAINT
; 
; note: deleting unreachable code

; --> BLOCK GETHASH SB-IMPL::GETHASH3 RACER::MAKE-CONSTRAINTS-TABLE-KEY BLOCK 
; --> COND IF IF IF LIST RACER::SIGNATURE-IND SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   NRQL-SYMBOLS:CONSTRAINT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer.lisp
; in: DEFUN SELECT-NEW-OR-CLAUSE-CANDIDATE
;     (RETURN RACER::SELECTED-CLAUSE-TERM)
; --> RETURN-FROM 
; ==>
;   RACER::SELECTED-CLAUSE-TERM
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer.lisp
; in:
;      RACE-INLINE (OLD-INDIVIDUAL-P TRUE-OLD-INDIVIDUAL-P OLDER-INDIVIDUAL-P ROOT-INDIVIDUAL-P SHIQ-BLOCKING-REQUIRED NEW-INDIVIDUAL-P PROVER-INDIVIDUAL-P)
;     (RACER::RACE-INLINE
;      (RACER::OLD-INDIVIDUAL-P RACER::TRUE-OLD-INDIVIDUAL-P
;       RACER::OLDER-INDIVIDUAL-P RACER::ROOT-INDIVIDUAL-P
;       RACER::SHIQ-BLOCKING-REQUIRED RACER::NEW-INDIVIDUAL-P
;       RACER::PROVER-INDIVIDUAL-P))
; --> DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM
;    '(INLINE RACER::OLD-INDIVIDUAL-P RACER::TRUE-OLD-INDIVIDUAL-P
;      RACER::OLDER-INDIVIDUAL-P RACER::ROOT-INDIVIDUAL-P
;      RACER::SHIQ-BLOCKING-REQUIRED RACER::NEW-INDIVIDUAL-P
;      RACER::PROVER-INDIVIDUAL-P)
;    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::OLD-INDIVIDUAL-P to be INLINE, but 20 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::TRUE-OLD-INDIVIDUAL-P to be INLINE, but 33 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::OLDER-INDIVIDUAL-P to be INLINE, but 3 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::SHIQ-BLOCKING-REQUIRED to be INLINE, but 2 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::NEW-INDIVIDUAL-P to be INLINE, but 1 call to it was previously compiled. A declaration of NOTINLINE at the call site will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer.lisp
; in: RACE-INLINE (TRUE-LABEL-INFO-P)
;     (RACER::RACE-INLINE (RACER::TRUE-LABEL-INFO-P))
; --> DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE RACER::TRUE-LABEL-INFO-P) (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::TRUE-LABEL-INFO-P to be INLINE, but 3 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/racer.lisp
; in: DEFUN TEST-SUBSUMES-2
;     (WHEN RACER::*DEBUG* (GET-INTERNAL-RUN-TIME))
; --> IF 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   This is not a NUMBER:
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "racer" "racer-kernel" "racer">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/gci-absorption.lisp
; in: DEFUN ABSORB-DOMAIN-RANGE-RESTRICTIONS
;     (IF (RACER::CONCEPT-P-INTERNAL RACER::GCI)
;         (LIST (RACER::CONCEPT-NEGATED-CONCEPT RACER::CD-CONCEPT)
;               (RACER::ENCODE-CONCEPT-TERM RACER::RIGHT))
;         RACER::GCI)
; ==>
;   RACER::GCI
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFSTRUCT (EL+-ENVIRONMENT (:CONC-NAME ENV-))
;     (PERSISTENCE-MANAGER:DEFSTRUCT
;      (RACER::EL+-ENVIRONMENT (:CONC-NAME RACER::ENV-)) (RACER::TBOX-LANGUAGE NIL)
;      (RACER::DAG NIL) (RACER::ROLE-MEMBERS NIL) (RACER::NARY-ABSORPTIONS NIL)
;      (RACER::INVERSE-ROLE-COMPOSITIONS NIL)
;      (RACER::CONCEPTS-USED-IN-DOMAIN-QUALIFICATION (RACER:RACER-MAKE-HASH-TABLE))
;      (RACER::ROLE-CHAIN-MEMBER-LIST NIL) (RACER::COMPOSED-ROLES NIL))
; --> PERSISTENCE-MANAGER:DEFPERSISTENTSTRUCT PROGN DEFSTRUCT PROGN EVAL-WHEN 
; ==>
;   (SB-KERNEL::%COMPILER-DEFSTRUCT
;    '#<SB-KERNEL:DEFSTRUCT-DESCRIPTION RACER::EL+-ENVIRONMENT {100E834A03}>
;    '#(#<SB-KERNEL:LAYOUT for T {50300003}>
;       #<SB-KERNEL:LAYOUT for STRUCTURE-OBJECT {50300083}>
;       #<SB-KERNEL:LAYOUT for PERSISTENCE-MANAGER::PERSISTENT-STRUCTURE {50544303}>))
; 
; caught STYLE-WARNING:
;   Previously compiled call to RACER::ENV-ROLE-MEMBERS could not be inlined because the structure definition for RACER::EL+-ENVIRONMENT was not yet seen. To avoid this warning, DEFSTRUCT should precede references to the affected functions, or they must be declared locally notinline at each call site.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN ALL-ROLES
;     (DEFUN RACER:ALL-ROLES
;            (
;             &OPTIONAL (RACER::TBOX RACER:*CURRENT-TBOX*)
;             &KEY (COUNT NIL) (RACER::TEST NIL) (RACER::INVERSE-TEST NIL)
;             (RACER:DEFAULT NIL))
;       (CHECK-TYPE RACER::TBOX (OR SYMBOL RACER::TBOX))
;       (SETF RACER::TBOX (RACER:FIND-TBOX RACER::TBOX))
;       (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':TBOX-PREPARED RACER::TBOX)
;       (RACER::POSSIBLY-COUNT-ONLY
;        (LOOP RACER::FOR RACER::ROLE RACER::IN (RACER::TBOX-ALL-ROLES RACER::TBOX)
;              WHEN (AND (SYMBOLP RACER::ROLE) (NOT #) (OR # #))
;              RACER::COLLECT RACER::ROLE RACER::INTO RACER::ROLES
;              WHEN ...)
;        COUNT))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:ALL-ROLES
;         (&OPTIONAL (RACER::TBOX RACER:*CURRENT-TBOX*) &KEY (COUNT NIL)
;          (RACER::TEST NIL) (RACER::INVERSE-TEST NIL) (RACER:DEFAULT NIL))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:ALL-ROLES
;         (CHECK-TYPE RACER::TBOX (OR SYMBOL RACER::TBOX))
;         (SETF RACER::TBOX (RACER:FIND-TBOX RACER::TBOX))
;         (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':TBOX-PREPARED RACER::TBOX)
;         (RACER::POSSIBLY-COUNT-ONLY
;          (LOOP RACER::FOR RACER::ROLE RACER::IN (RACER::TBOX-ALL-ROLES
;                                                  RACER::TBOX)
;                WHEN (AND # # #)
;                RACER::COLLECT RACER::ROLE RACER::INTO RACER::ROLES
;                WHEN ...)
;          COUNT)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (TBOX *CURRENT-TBOX*) &KEY (COUNT NIL) (TEST NIL) (INVERSE-TEST NIL) (DEFAULT NIL))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN ALL-FEATURES
;     (DEFUN RACER:ALL-FEATURES
;            (&OPTIONAL (RACER::TBOX RACER:*CURRENT-TBOX*) &KEY (COUNT NIL))
;       (CHECK-TYPE RACER::TBOX (OR SYMBOL RACER::TBOX))
;       (SETF RACER::TBOX (RACER:FIND-TBOX RACER::TBOX))
;       (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':TBOX-PREPARED RACER::TBOX)
;       (RACER::POSSIBLY-COUNT-ONLY (RACER::TBOX-ALL-FEATURES RACER::TBOX) COUNT))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:ALL-FEATURES
;         (&OPTIONAL (RACER::TBOX RACER:*CURRENT-TBOX*) &KEY (COUNT NIL))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:ALL-FEATURES
;         (CHECK-TYPE RACER::TBOX (OR SYMBOL RACER::TBOX))
;         (SETF RACER::TBOX (RACER:FIND-TBOX RACER::TBOX))
;         (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':TBOX-PREPARED RACER::TBOX)
;         (RACER::POSSIBLY-COUNT-ONLY (RACER::TBOX-ALL-FEATURES RACER::TBOX)
;                                     COUNT)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (TBOX *CURRENT-TBOX*) &KEY (COUNT NIL))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN ALL-TRANSITIVE-ROLES
;     (DEFUN RACER:ALL-TRANSITIVE-ROLES
;            (&OPTIONAL (RACER::TBOX RACER:*CURRENT-TBOX*) &KEY (COUNT NIL))
;       (CHECK-TYPE RACER::TBOX (OR SYMBOL RACER::TBOX))
;       (SETF RACER::TBOX (RACER:FIND-TBOX RACER::TBOX))
;       (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':TBOX-PREPARED RACER::TBOX)
;       (RACER::POSSIBLY-COUNT-ONLY (RACER::TBOX-ALL-TRANSITIVE-ROLES RACER::TBOX)
;                                   COUNT))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:ALL-TRANSITIVE-ROLES
;         (&OPTIONAL (RACER::TBOX RACER:*CURRENT-TBOX*) &KEY (COUNT NIL))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:ALL-TRANSITIVE-ROLES
;         (CHECK-TYPE RACER::TBOX (OR SYMBOL RACER::TBOX))
;         (SETF RACER::TBOX (RACER:FIND-TBOX RACER::TBOX))
;         (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':TBOX-PREPARED RACER::TBOX)
;         (RACER::POSSIBLY-COUNT-ONLY
;          (RACER::TBOX-ALL-TRANSITIVE-ROLES RACER::TBOX) COUNT)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (TBOX *CURRENT-TBOX*) &KEY (COUNT NIL))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN ALL-ATTRIBUTES
;     (DEFUN RACER:ALL-ATTRIBUTES
;            (&OPTIONAL (RACER::TBOX RACER:*CURRENT-TBOX*) &KEY (COUNT NIL))
;       (CHECK-TYPE RACER::TBOX (OR SYMBOL RACER::TBOX))
;       (SETF RACER::TBOX (RACER:FIND-TBOX RACER::TBOX))
;       (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':TBOX-PREPARED RACER::TBOX)
;       (RACER::POSSIBLY-COUNT-ONLY
;        (LOOP RACER::FOR RACER::ATTRIBUTE RACER::IN (RACER::TBOX-ALL-ATTRIBUTES
;                                                     RACER::TBOX)
;              UNLESS (MEMBER RACER::ATTRIBUTE RACER::+INTERNAL-ROLES+)
;              RACER::COLLECT RACER::ATTRIBUTE)
;        COUNT))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:ALL-ATTRIBUTES
;         (&OPTIONAL (RACER::TBOX RACER:*CURRENT-TBOX*) &KEY (COUNT NIL))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:ALL-ATTRIBUTES
;         (CHECK-TYPE RACER::TBOX (OR SYMBOL RACER::TBOX))
;         (SETF RACER::TBOX (RACER:FIND-TBOX RACER::TBOX))
;         (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':TBOX-PREPARED RACER::TBOX)
;         (RACER::POSSIBLY-COUNT-ONLY
;          (LOOP RACER::FOR RACER::ATTRIBUTE RACER::IN (RACER::TBOX-ALL-ATTRIBUTES
;                                                       RACER::TBOX)
;                UNLESS (MEMBER RACER::ATTRIBUTE RACER::+INTERNAL-ROLES+)
;                RACER::COLLECT RACER::ATTRIBUTE)
;          COUNT)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (TBOX *CURRENT-TBOX*) &KEY (COUNT NIL))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: RACE-INLINE (GET-TBOX-CONCEPT)
;     (RACER::RACE-INLINE (RACER::GET-TBOX-CONCEPT))
; --> DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE RACER::GET-TBOX-CONCEPT) (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::GET-TBOX-CONCEPT to be INLINE, but 4 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFSTRUCT (CONCEPTS-BUCKET (:CONC-NAME BUCKET-))
;     (PERSISTENCE-MANAGER:DEFSTRUCT
;      (RACER::CONCEPTS-BUCKET (:CONC-NAME RACER::BUCKET-))
;      (RACER::CONCEPT-INTERNAL NIL) (RACER::PARENT NIL) (RACER::MEMBERS NIL)
;      (RACER::MARK1 NIL) (RACER::MEMBERS-COUNT 0)
;      (RACER::MEMBERS-LANGUAGE RACER::*DL-EMPTY*) (RACER::MEMBER-DEFINED-P NIL))
; --> PERSISTENCE-MANAGER:DEFPERSISTENTSTRUCT PROGN DEFSTRUCT PROGN EVAL-WHEN 
; ==>
;   (SB-KERNEL::%COMPILER-DEFSTRUCT
;    '#<SB-KERNEL:DEFSTRUCT-DESCRIPTION RACER::CONCEPTS-BUCKET {1011086B43}>
;    '#(#<SB-KERNEL:LAYOUT for T {50300003}>
;       #<SB-KERNEL:LAYOUT for STRUCTURE-OBJECT {50300083}>
;       #<SB-KERNEL:LAYOUT for PERSISTENCE-MANAGER::PERSISTENT-STRUCTURE {50544303}>))
; 
; caught STYLE-WARNING:
;   Previously compiled calls to RACER::CONCEPTS-BUCKET-P, RACER::BUCKET-MEMBERS, RACER::BUCKET-MEMBERS-LANGUAGE and RACER::BUCKET-MEMBER-DEFINED-P could not be inlined because the structure definition for RACER::CONCEPTS-BUCKET was not yet seen. To avoid this warning, DEFSTRUCT should precede references to the affected functions, or they must be declared locally notinline at each call site.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN ADD-ROLE-AXIOMS
;     (LIST RACER::PARENTS)
; --> CONS 
; ==>
;   RACER::PARENTS
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN ROLE-IS-ASYMMETRIC
;     (SECOND RACER::ROLENAME)
; --> CADR CAR CDR 
; ==>
;   RACER::ROLENAME
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: RACE-INLINE (SUBROLE-P SAFE-GET-TBOX-ROLE)
;     (RACER::RACE-INLINE (RACER::SUBROLE-P RACER::SAFE-GET-TBOX-ROLE))
; --> DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE RACER::SUBROLE-P RACER::SAFE-GET-TBOX-ROLE)
;                    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming RACER::SUBROLE-P to be INLINE, but 29 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN ALL-ATOMIC-CONCEPTS
;     (DEFUN RACER:ALL-ATOMIC-CONCEPTS
;            (&OPTIONAL (RACER::TBOX RACER:*CURRENT-TBOX*) &KEY (COUNT NIL))
;       (SETF RACER::TBOX (RACER:FIND-TBOX RACER::TBOX))
;       (CHECK-TYPE RACER::TBOX RACER::TBOX)
;       (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':TBOX-PREPARED RACER::TBOX)
;       (RACER::POSSIBLY-COUNT-ONLY
;        (LET ((RACER::RESULT NIL))
;          (LOOP RACER::FOR RACER::CONCEPT RACER::BEING THE RACER::HASH-VALUES RACER::OF (RACER::TBOX-CONCEPT-STORE
;                                                                                         RACER::TBOX)
;                WHEN (AND # #)
;                DO (LOOP RACER::FOR RACER::NAME RACER::IN #
;                         UNLESS #
;                         DO #))
;          (REMOVE-DUPLICATES (LIST* 'NRQL-SYMBOLS:TOP 'NRQL-SYMBOLS:BOTTOM #)))
;        COUNT))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:ALL-ATOMIC-CONCEPTS
;         (&OPTIONAL (RACER::TBOX RACER:*CURRENT-TBOX*) &KEY (COUNT NIL))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:ALL-ATOMIC-CONCEPTS
;         (SETF RACER::TBOX (RACER:FIND-TBOX RACER::TBOX))
;         (CHECK-TYPE RACER::TBOX RACER::TBOX)
;         (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':TBOX-PREPARED RACER::TBOX)
;         (RACER::POSSIBLY-COUNT-ONLY
;          (LET (#)
;            (LOOP RACER::FOR RACER::CONCEPT RACER::BEING THE RACER::HASH-VALUES RACER::OF #
;                  WHEN #
;                  DO #)
;            (REMOVE-DUPLICATES #))
;          COUNT)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (TBOX *CURRENT-TBOX*) &KEY (COUNT NIL))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN ALL-EQUIVALENT-CONCEPTS
;     (DEFUN RACER:ALL-EQUIVALENT-CONCEPTS
;            (&OPTIONAL (RACER::TBOX RACER:*CURRENT-TBOX*) &KEY (COUNT NIL))
;       (SETF RACER::TBOX (RACER:FIND-TBOX RACER::TBOX))
;       (CHECK-TYPE RACER::TBOX RACER::TBOX)
;       (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':TBOX-CLASSIFIED RACER::TBOX)
;       (RACER::POSSIBLY-COUNT-ONLY
;        (LET ((RACER::TBOX-TOP-NODE #) (RACER::TBOX-BOTTOM-NODE #))
;          (LIST* (RACER::CONCEPT-NAME-SET RACER::TBOX-TOP-NODE)
;                 (RACER::CONCEPT-NAME-SET RACER::TBOX-BOTTOM-NODE)
;                 (LOOP RACER::FOR RACER::CONCEPT RACER::BEING THE RACER::HASH-VALUES RACER::OF #
;                       WHEN #
;                       RACER::COLLECT #)))
;        COUNT))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:ALL-EQUIVALENT-CONCEPTS
;         (&OPTIONAL (RACER::TBOX RACER:*CURRENT-TBOX*) &KEY (COUNT NIL))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:ALL-EQUIVALENT-CONCEPTS
;         (SETF RACER::TBOX (RACER:FIND-TBOX RACER::TBOX))
;         (CHECK-TYPE RACER::TBOX RACER::TBOX)
;         (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':TBOX-CLASSIFIED RACER::TBOX)
;         (RACER::POSSIBLY-COUNT-ONLY
;          (LET (# #)
;            (LIST* # # #))
;          COUNT)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (TBOX *CURRENT-TBOX*) &KEY (COUNT NIL))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN CONCEPT-P
;     (RACER::GET-TBOX-CONCEPT RACER::TBOX RACER::CONCEPT-NAME NIL)
; --> BLOCK LET* IF IF ERROR 
; ==>
;   RACER::CONCEPT-NAME
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN ENCODE-UPDATE-CONCEPT-TERM
;     (RACER::GET-TBOX-CONCEPT RACER::TBOX RACER::CONCEPT-TERM NIL)
; --> BLOCK LET* IF IF ERROR RACER:TBOX-NAME SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::TBOX
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN COMPUTE-ENCODED-CONCEPT-LIST
;     (RACER::GET-TBOX-CONCEPT RACER::TBOX RACER::NAME NIL)
; --> BLOCK LET* IF IF ERROR RACER:TBOX-NAME SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::TBOX
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN CHECK-META-CONCEPTS
;     (WHEN RACER::*DEBUG* (GET-INTERNAL-RUN-TIME))
; --> IF 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   This is not a NUMBER:
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN CLASSIFY-ROLE-HIERARCHY
;     (WHEN RACER::*DEBUG* (GET-INTERNAL-RUN-TIME))
; --> IF 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   This is not a NUMBER:
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN INTERNALIZE-ROLE-MIRROR-CONCEPTS-INTERNAL
;     (RACER::GET-TBOX-CONCEPT RACER::TBOX RACER::CHILD-CONCEPT-NAME NIL)
; --> BLOCK LET* IF IF ERROR RACER:TBOX-NAME SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::TBOX
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN MIRROR-CONCEPTS-TO-ROLES
;     (RACER::GET-TBOX-CONCEPT RACER::TBOX RACER::CONCEPT-NAME)
; --> BLOCK LET* AND IF GETHASH SB-IMPL::GETHASH3 
; ==>
;   RACER::CONCEPT-NAME
; 
; note: deleting unreachable code

; --> BLOCK LET* RACER::TBOX-CONCEPT-STORE SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::TBOX
; 
; note: deleting unreachable code

; --> BLOCK LET* IF IF ERROR 
; ==>
;   RACER::CONCEPT-NAME
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN CONVERT-ROLE-DESCENDANTS-TO-FEATURES
;     (RACER::GET-TBOX-CONCEPT RACER::TBOX
;      (OR (GETHASH RACER::DESCENDANT RACER::ROLE-TO-CONCEPT-NAME)
;          (GETHASH (RACER::ROLE-INVERSE-INTERNAL RACER::DESCENDANT)
;                   RACER::ROLE-TO-CONCEPT-NAME))
;      NIL)
; --> BLOCK LET* IF IF ERROR RACER:TBOX-NAME SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::TBOX
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN CHECK-TBOX-COHERENCE
;     (DEFUN RACER:CHECK-TBOX-COHERENCE
;            (
;             &OPTIONAL (RACER::TBOX RACER:*CURRENT-TBOX*)
;             &KEY (STREAM *STANDARD-OUTPUT*))
;       (CHECK-TYPE RACER::TBOX (OR SYMBOL RACER::TBOX))
;       (SETF RACER::TBOX (RACER:FIND-TBOX RACER::TBOX))
;       (RACER::WITH-RACE-TRACE-SUBLEVEL ("check-tbox-coherence" :ARGUMENTS
;                                         (LIST RACER::TBOX) :EXPANDED T
;                                         :TRACE-RESULT T)
;         (RACER::ENSURE-TBOX-STATE RACER::TBOX :COHERENCE-ONLY :STREAM STREAM)
;         (LET ((RACER::UNSATISFIABLE-CONCEPTS #) (RACER::UNSATISFIABLE-ROLES #))
;           (SETF # #)
;           (LIST RACER::UNSATISFIABLE-CONCEPTS RACER::UNSATISFIABLE-ROLES))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:CHECK-TBOX-COHERENCE
;         (&OPTIONAL (RACER::TBOX RACER:*CURRENT-TBOX*) &KEY
;          (STREAM *STANDARD-OUTPUT*))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:CHECK-TBOX-COHERENCE
;         (CHECK-TYPE RACER::TBOX (OR SYMBOL RACER::TBOX))
;         (SETF RACER::TBOX (RACER:FIND-TBOX RACER::TBOX))
;         (RACER::WITH-RACE-TRACE-SUBLEVEL ("check-tbox-coherence" :ARGUMENTS
;                                           (LIST RACER::TBOX) :EXPANDED T
;                                           :TRACE-RESULT T)
;           (RACER::ENSURE-TBOX-STATE RACER::TBOX :COHERENCE-ONLY :STREAM STREAM)
;           (LET (# #)
;             (SETF #)
;             (LIST RACER::UNSATISFIABLE-CONCEPTS RACER::UNSATISFIABLE-ROLES)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (TBOX *CURRENT-TBOX*) &KEY (STREAM *STANDARD-OUTPUT*))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN UNMARK-POSSIBLE-SUBSUMEES-IF-DISJOINT
;     (RACER::GET-TBOX-CONCEPT RACER::TBOX
;      (FIRST (RACER::CONCEPT-NAME-SET RACER::CONCEPT-1)) NIL)
; --> BLOCK LET* IF IF ERROR RACER:TBOX-NAME SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::TBOX
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN INSERT-CONCEPT-INTO-TBOX
;     (RACER::GET-TBOX-CONCEPT RACER::TBOX
;      (FIRST (RACER::CONCEPT-NAME-SET RACER::ENCODED-DEFINITION)))
; --> BLOCK LET* IF IF 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   This is not a RACER::CONCEPT-NODE:
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN PROCESS-ROLE-RANGE
;     (DEFUN RACER::PROCESS-ROLE-RANGE
;            (RACER::LHS RACER::ROLE RACER::RHS RACER::ENVIRONMENT)
;       (LET ((RACER:RANGE (RACER::ROLE-RANGE-RESTRICTION RACER::ROLE)))
;         (WHEN RACER:RANGE
;           (RACER::PROCESS-SUBSUMPTION-AXIOMS RACER::RHS RACER:RANGE
;            RACER::ENVIRONMENT))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER::PROCESS-ROLE-RANGE
;         (RACER::LHS RACER::ROLE RACER::RHS RACER::ENVIRONMENT)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER::PROCESS-ROLE-RANGE
;         (LET ((RACER:RANGE #))
;           (WHEN RACER:RANGE
;             (RACER::PROCESS-SUBSUMPTION-AXIOMS RACER::RHS RACER:RANGE
;              RACER::ENVIRONMENT)))))
; 
; caught STYLE-WARNING:
;   The variable LHS is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN INSERT-ANONYMOUS-CONCEPT-INTO-TBOX
;     (RACER::GET-TBOX-CONCEPT RACER::TBOX
;      (FIRST (RACER::CONCEPT-NAME-SET RACER::CONCEPT-1)))
; --> BLOCK LET* IF IF 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   This is not a RACER::CONCEPT-NODE:
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN CONCEPT-IS-PRIMITIVE-P
;     (RACER::GET-TBOX-CONCEPT RACER::TBOX RACER::CONCEPT-NAME)
; --> BLOCK LET* IF IF 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   This is not a RACER::CONCEPT-NODE:
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN DUMP-CONCEPT-TREE
;     (WITH-OPEN-FILE
;         (STREAM RACER::FILENAME :DIRECTION :OUTPUT :IF-EXISTS :SUPERSEDE)
;       (RACER::PRINT-CONCEPT-TREE :STREAM STREAM :TBOX RACER::TBOX :ONLY-PARENTS
;        RACER::ONLY-PARENTS :AS-LIST NIL))
; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM 
; ==>
;   (MULTIPLE-VALUE-PROG1
;       (PROGN
;        (RACER::PRINT-CONCEPT-TREE :STREAM STREAM :TBOX RACER::TBOX
;         :ONLY-PARENTS RACER::ONLY-PARENTS :AS-LIST NIL))
;     (SETQ #:G1 NIL))
; 
; note: type assertion too complex to check:
; (VALUES &OPTIONAL CONS).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN PRINT-ANONYMIZED-TBOX
;     (RACER::GET-TBOX-CONCEPT RACER::TBOX RACER::CNAME)
; --> BLOCK LET* IF IF 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   This is not a RACER::CONCEPT:
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN SAVE-TBOX
;     (DEFUN RACER:SAVE-TBOX
;            (RACER::PATHNAME-OR-STREAM
;             &OPTIONAL (RACER::TBOX RACER:*CURRENT-TBOX*)
;             &KEY (RACER::SYNTAX :KRSS-LIKE) (RACER::TRANSFORMED NIL)
;             (RACER::AVOID-DUPLICATE-DEFINITIONS NIL)
;             (RACER::IF-EXISTS :SUPERSEDE) (RACER::IF-DOES-NOT-EXIST :CREATE)
;             (RACER::URI NIL) (RACER::ANONYMIZED NIL) (RACER::HEADER T))
;       (CHECK-TYPE RACER::TBOX (OR SYMBOL RACER::TBOX))
;       (CHECK-TYPE RACER::PATHNAME-OR-STREAM (OR PATHNAME STRING FILE-STREAM))
;       (CHECK-TYPE RACER::SYNTAX
;                   (MEMBER :KRSS :KRSS-LIKE :RACER :TEST :SHIQ :XML :OWL))
;       (SETF RACER::TBOX (RACER:FIND-TBOX RACER::TBOX))
;       (IF (RACER::TBOX-USE-LESS-MEMORY RACER::TBOX)
;           (RACER:RACER-WARN
;            #<(SIMPLE-ARRAY CHARACTER
;               (221)) ~&Saving Tbox axioms ~A is only partially supported due to the ~
;                    current memory management strategy. Some axioms might be missing. ~
;                    Start Racer with option -x to ena... {1012444C6F}>
;            (RACER:TBOX-NAME RACER::TBOX))
;           (FLET ((RACER::SAVE-TBOX-1 #
;                    #))
;             (LET (#)
;               (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':TBOX-PREPARED RACER::TBOX)
;               (RACER::WITH-CONCEPT-DEFINITION-MAPPING RACER::TBOX
;                 #)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:SAVE-TBOX
;         (RACER::PATHNAME-OR-STREAM &OPTIONAL (RACER::TBOX RACER:*CURRENT-TBOX*)
;          &KEY (RACER::SYNTAX :KRSS-LIKE) (RACER::TRANSFORMED NIL)
;          (RACER::AVOID-DUPLICATE-DEFINITIONS NIL) (RACER::IF-EXISTS :SUPERSEDE)
;          (RACER::IF-DOES-NOT-EXIST :CREATE) (RACER::URI NIL)
;          (RACER::ANONYMIZED NIL) (RACER::HEADER T))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:SAVE-TBOX
;         (CHECK-TYPE RACER::TBOX (OR SYMBOL RACER::TBOX))
;         (CHECK-TYPE RACER::PATHNAME-OR-STREAM (OR PATHNAME STRING FILE-STREAM))
;         (CHECK-TYPE RACER::SYNTAX
;                     (MEMBER :KRSS :KRSS-LIKE :RACER :TEST :SHIQ :XML :OWL))
;         (SETF RACER::TBOX (RACER:FIND-TBOX RACER::TBOX))
;         (IF (RACER::TBOX-USE-LESS-MEMORY RACER::TBOX)
;             (RACER:RACER-WARN
;              #<(SIMPLE-ARRAY CHARACTER
;                 (221)) ~&Saving Tbox axioms ~A is only partially supported due to the ~
;                  current memory management strategy. Some axioms might be missing. ~
;                  Start Racer with option -x to ena... {1012444C6F}>
;              (RACER:TBOX-NAME RACER::TBOX))
;             (FLET (#)
;               (LET #
;                 #
;                 #)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (PATHNAME-OR-STREAM &OPTIONAL (TBOX *CURRENT-TBOX*) &KEY (SYNTAX :KRSS-LIKE) (TRANSFORMED NIL) (AVOID-DUPLICATE-DEFINITIONS NIL) (IF-EXISTS :SUPERSEDE) (IF-DOES-NOT-EXIST :CREATE) (URI NIL) (ANONYMIZED NIL) (HEADER T))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tbox.lisp
; in: DEFUN PRINT-TBOX-XMAS-TREE
;     (IF (INTEGERP RACER::WIDTH)
;         RACER::WIDTH
;         (1+ (TRUNCATE RACER::WIDTH)))
; ==>
;   RACER::WIDTH
; 
; note: deleting unreachable code
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "racer" "racer-tools" "tbox">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in:
;      DEFSTRUCT (ABOX (:CONSTRUCTOR MAKE-ABOX-INTERNAL) (:COPIER COPY-ABOX-INTERNAL))
;     (PERSISTENCE-MANAGER:DEFSTRUCT
;      (RACER::ABOX (:CONSTRUCTOR RACER::MAKE-ABOX-INTERNAL)
;       (:COPIER RACER::COPY-ABOX-INTERNAL))
;      (RACER::NAME NIL) (RACER::TBOX NIL) (RACER::TBOX-IDENTIFICATION NIL)
;      (RACER::INDIVIDUALS-TABLE (RACER:RACER-MAKE-HASH-TABLE))
;      (RACER::INDIVIDUALS-LIST NIL)
;      (RACER::OBJECTS-TABLE (RACER:RACER-MAKE-HASH-TABLE))
;      (RACER::OBJECTS-LIST NIL) (RACER::OBJECT-SYNONYM-TABLE NIL)
;      (RACER::SUBGRAPHS NIL) (RACER::INDEX-STRUCTURES-COMPLETE-P NIL) ...)
; --> PERSISTENCE-MANAGER:DEFPERSISTENTSTRUCT PROGN DEFSTRUCT PROGN EVAL-WHEN 
; ==>
;   (SB-KERNEL::%COMPILER-DEFSTRUCT
;    '#<SB-KERNEL:DEFSTRUCT-DESCRIPTION RACER::ABOX {10105A2083}>
;    '#(#<SB-KERNEL:LAYOUT for T {50300003}>
;       #<SB-KERNEL:LAYOUT for STRUCTURE-OBJECT {50300083}>
;       #<SB-KERNEL:LAYOUT for PERSISTENCE-MANAGER::PERSISTENT-STRUCTURE {50544303}>))
; 
; caught STYLE-WARNING:
;   Previously compiled calls to RACER:ABOX-NAME, RACER::ABOX-TBOX, RACER::ABOX-INDIVIDUALS-LIST, RACER::ABOX-SUBGRAPHS, RACER::ABOX-LANGUAGE, RACER::ABOX-INDIVIDUAL-AXIOMS, RACER::ABOX-ROLE-AXIOMS, RACER::ABOX-NEGATED-ROLE-AXIOMS, RACER::ABOX-INITIAL-CONSTRAINT-STATE, RACER::ABOX-CURRENT-UNA-ASSUMPTION and RACER::ABOX-EL+-TRANSFORMED-TABLE could not be inlined because the structure definition for RACER::ABOX was not yet seen. To avoid this warning, DEFSTRUCT should precede references to the affected functions, or they must be declared locally notinline at each call site.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN REPLACE-RHS-COMPLEX-SOME-CONCEPTS-1
;     (RACER::CONCEPT-TERM RACER::TERM)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::TERM
; 
; note: deleting unreachable code

;     (RACER::REPLACE-RHS-COMPLEX-SOME-CONCEPT RACER::TBOX RACER::CONJUNCT
;      RACER::ORIG-TERM RACER::EL+-TRANSFORMATION-TABLE)
; ==>
;   RACER::TBOX
; 
; note: deleting unreachable code

;     (LOOP RACER::FOR RACER::CONJUNCT RACER::IN (RACER::CONCEPT-TERM RACER::TERM)
;           RACER::FOR RACER::ADDED-ASSERTION-TERM = NIL
;           WHEN (AND (RACER::SOME-CONCEPT-P RACER::TERM)
;                     (NOT
;                      (RACER::ATOMIC-CONCEPT-P
;                       (RACER::CONCEPT-TERM RACER::TERM))))
;           DO ...)
; --> BLOCK LET LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* 
; --> SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* TAGBODY IF PROGN 
; --> SB-LOOP::LOOP-COLLECT-RPLACD PROGN RPLACD LET PROGN SETF 
; --> SB-KERNEL:%RPLACD SETQ THE LIST CONS 
; ==>
;   RACER::ADDED-ASSERTION-TERM
; 
; note: deleting unreachable code

; ==>
;   RACER::CONJUNCT
; 
; note: deleting unreachable code

;     (LET ((RACER::REMAINING-CONJUNCTS
;            (RACER::CONCEPT-SET-DIFFERENCE (RACER::CONCEPT-TERM RACER::TERM)
;                                           RACER::REMOVED-CONCEPTS)))
;       (IF RACER::REMAINING-CONJUNCTS
;           (RETURN
;            (VALUES (CONS `# RACER::ADDED-ASSERTION-TERMS)
;                    RACER::EL+-TRANSFORMATION-TABLE))
;           (RETURN
;            (VALUES RACER::ADDED-ASSERTION-TERMS
;                    RACER::EL+-TRANSFORMATION-TABLE))))
; 
; note: deleting unreachable code

;     (CONS `(AND . ,RACER::REMAINING-CONJUNCTS) RACER::ADDED-ASSERTION-TERMS)
; ==>
;   RACER::ADDED-ASSERTION-TERMS
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

;     (VALUES RACER::ADDED-ASSERTION-TERMS RACER::EL+-TRANSFORMATION-TABLE)
; ==>
;   RACER::EL+-TRANSFORMATION-TABLE
; 
; note: deleting unreachable code

; ==>
;   RACER::ADDED-ASSERTION-TERMS
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN INITIALIZE-ABOX
;     (NOT RACER::NEW-P)
; --> IF 
; ==>
;   RACER::NEW-P
; 
; note: deleting unreachable code

;     (SETF (RACER::ABOX-ROLE-AXIOMS RACER::OLD-ABOX)
;             (LOOP RACER::FOR RACER::SUBGRAPH RACER::IN (RACER::ABOX-SUBGRAPHS
;                                                         RACER::OLD-ABOX)
;                   NCONC (LOOP RACER::FOR RACER::ASSERTION RACER::IN (RACER::SUBGRAPH-ENCODED-ROLE-AXIOMS
;                                                                      RACER::SUBGRAPH)
;                               RACER::COLLECT (LIST # #))))
; --> SB-KERNEL:%INSTANCE-SET THE 
; ==>
;   RACER::OLD-ABOX
; 
; note: deleting unreachable code

;     (RACER::ABOX-SUBGRAPHS RACER::OLD-ABOX)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::OLD-ABOX
; 
; note: deleting unreachable code

;     (RACER::SUBGRAPH-ENCODED-ROLE-AXIOMS RACER::SUBGRAPH)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::SUBGRAPH
; 
; note: deleting unreachable code

;     (RACER::CONSTRAINT-IND-1 RACER::ASSERTION)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::ASSERTION
; 
; note: deleting unreachable code

;     (SETF (RACER::ABOX-INDIVIDUAL-AXIOMS RACER::OLD-ABOX)
;             (LOOP RACER::FOR RACER::SUBRAPH RACER::IN (RACER::ABOX-SUBGRAPHS
;                                                        RACER::OLD-ABOX)
;                   NCONC (LOOP RACER::FOR RACER::ASSERTION RACER::IN (RACER::SUBGRAPH-ENCODED-INDIVIDUAL-AXIOMS
;                                                                      RACER::SUBRAPH)
;                               RACER::COLLECT (LIST # #))))
; --> SB-KERNEL:%INSTANCE-SET THE 
; ==>
;   RACER::OLD-ABOX
; 
; note: deleting unreachable code

;     (RACER::ABOX-SUBGRAPHS RACER::OLD-ABOX)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::OLD-ABOX
; 
; note: deleting unreachable code

;     (RACER::SUBGRAPH-ENCODED-INDIVIDUAL-AXIOMS RACER::SUBRAPH)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::SUBRAPH
; 
; note: deleting unreachable code

;     (FIRST RACER::ASSERTION)
; --> CAR 
; ==>
;   RACER::ASSERTION
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN ALL-INDIVIDUALS
;     (DEFUN RACER:ALL-INDIVIDUALS
;            (&OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*) &KEY (COUNT NIL))
;       (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;       (CHECK-TYPE RACER::ABOX RACER::ABOX)
;       (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;       (RACER::POSSIBLY-COUNT-ONLY
;        (LET ((RACER::RESULT NIL))
;          (LOOP RACER::FOR RACER::IND RACER::IN (RACER::ABOX-INDIVIDUALS-LIST
;                                                 RACER::ABOX)
;                DO (LOOP RACER::FOR RACER::IND-NAME RACER::IN #
;                         DO #))
;          RACER::RESULT)
;        COUNT))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:ALL-INDIVIDUALS
;         (&OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*) &KEY (COUNT NIL))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:ALL-INDIVIDUALS
;         (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;         (CHECK-TYPE RACER::ABOX RACER::ABOX)
;         (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;         (RACER::POSSIBLY-COUNT-ONLY
;          (LET (#)
;            (LOOP RACER::FOR RACER::IND RACER::IN #
;                  DO #)
;            RACER::RESULT)
;          COUNT)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (ABOX *CURRENT-ABOX*) &KEY (COUNT NIL))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN ABOX-SATISFIABLE
;     (WHEN RACER::*DEBUG* (GET-INTERNAL-RUN-TIME))
; --> IF 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   This is not a NUMBER:
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN GET-CACHED-INDIVIDUAL-MODEL
;     (RACER::GET-TBOX-CONCEPT (RACER::ABOX-TBOX RACER::ABOX)
;                              (RACER::INDIVIDUAL-CONCEPT-NAME RACER::IND))
; --> BLOCK LET* IF IF 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   This is not a RACER::CONCEPT:
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN OBVIOUSLY-IND-NOT-SUBSUMES
;     (EQ (RACER::CONCEPT-ENCODED-DEFINITION (RACER::CONCEPT-TERM RACER::CONCEPT))
;         NRQL-SYMBOLS:TOP)
; ==>
;   NRQL-SYMBOLS:TOP
; 
; note: deleting unreachable code

;     (RACER::CONCEPT-TERM RACER::CONCEPT)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::CONCEPT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN TEST-IND-SUBSUMES
;     (WHEN RACER::*DEBUG* (GET-INTERNAL-RUN-TIME))
; --> IF 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   This is not a NUMBER:
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN CONSTRAINT-ENTAILED-P
;     (RACER::SUBGRAPH-PRECOMPLETION RACER::SUBGRAPH)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::SUBGRAPH
; 
; note: deleting unreachable code

;     (WHEN RACER::*DEBUG* (GET-INTERNAL-RUN-TIME))
; --> IF 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   This is not a NUMBER:
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN TEST-IND-SUBSUMES-INCOMPLETE
;     (WHEN RACER::*DEBUG* (GET-INTERNAL-RUN-TIME))
; --> IF 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   This is not a NUMBER:
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN INSTANCE-TEST-NOT-SUCESSFUL
;     (WHEN RACER::*DEBUG* (GET-INTERNAL-RUN-TIME))
; --> IF 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   This is not a NUMBER:
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN ALL-CONCEPT-ASSERTIONS-FOR-INDIVIDUAL
;     (DEFUN RACER:ALL-CONCEPT-ASSERTIONS-FOR-INDIVIDUAL
;            (RACER::INDIVIDUAL
;             &OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*)
;             &KEY (COUNT NIL))
;       (CHECK-TYPE RACER::INDIVIDUAL SYMBOL)
;       (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;       (CHECK-TYPE RACER::ABOX RACER::ABOX)
;       (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;       (RACER::POSSIBLY-COUNT-ONLY
;        (RACER::INDIVIDUAL-ASSERTIONS
;         (RACER::FIND-INDIVIDUAL RACER::ABOX RACER::INDIVIDUAL))
;        COUNT))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:ALL-CONCEPT-ASSERTIONS-FOR-INDIVIDUAL
;         (RACER::INDIVIDUAL &OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*) &KEY
;          (COUNT NIL))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:ALL-CONCEPT-ASSERTIONS-FOR-INDIVIDUAL
;         (CHECK-TYPE RACER::INDIVIDUAL SYMBOL)
;         (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;         (CHECK-TYPE RACER::ABOX RACER::ABOX)
;         (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;         (RACER::POSSIBLY-COUNT-ONLY
;          (RACER::INDIVIDUAL-ASSERTIONS
;           (RACER::FIND-INDIVIDUAL RACER::ABOX RACER::INDIVIDUAL))
;          COUNT)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (INDIVIDUAL &OPTIONAL (ABOX *CURRENT-ABOX*) &KEY (COUNT NIL))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN ALL-ROLE-ASSERTIONS-FOR-INDIVIDUAL-IN-DOMAIN
;     (DEFUN RACER:ALL-ROLE-ASSERTIONS-FOR-INDIVIDUAL-IN-DOMAIN
;            (RACER::INDIVIDUAL
;             &OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*)
;             &KEY (COUNT NIL))
;       (CHECK-TYPE RACER::INDIVIDUAL SYMBOL)
;       (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;       (CHECK-TYPE RACER::ABOX RACER::ABOX)
;       (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;       (RACER::POSSIBLY-COUNT-ONLY
;        (LOOP RACER::FOR NRQL-SYMBOLS:CONSTRAINT RACER::IN (RACER::INDIVIDUAL-OUTGOING-ROLE-ASSERTIONS
;                                                            (RACER::FIND-INDIVIDUAL
;                                                             RACER::ABOX
;                                                             RACER::INDIVIDUAL))
;              RACER::COLLECT `((,# ,#) ,(RACER::ROLE-NAME #)))
;        COUNT))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:ALL-ROLE-ASSERTIONS-FOR-INDIVIDUAL-IN-DOMAIN
;         (RACER::INDIVIDUAL &OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*) &KEY
;          (COUNT NIL))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:ALL-ROLE-ASSERTIONS-FOR-INDIVIDUAL-IN-DOMAIN
;         (CHECK-TYPE RACER::INDIVIDUAL SYMBOL)
;         (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;         (CHECK-TYPE RACER::ABOX RACER::ABOX)
;         (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;         (RACER::POSSIBLY-COUNT-ONLY
;          (LOOP RACER::FOR NRQL-SYMBOLS:CONSTRAINT RACER::IN (RACER::INDIVIDUAL-OUTGOING-ROLE-ASSERTIONS
;                                                              #)
;                RACER::COLLECT `(# ,#))
;          COUNT)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (INDIVIDUAL &OPTIONAL (ABOX *CURRENT-ABOX*) &KEY (COUNT NIL))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN ALL-ROLE-ASSERTIONS-FOR-INDIVIDUAL-IN-RANGE
;     (DEFUN RACER:ALL-ROLE-ASSERTIONS-FOR-INDIVIDUAL-IN-RANGE
;            (RACER::INDIVIDUAL
;             &OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*)
;             &KEY (COUNT NIL))
;       (CHECK-TYPE RACER::INDIVIDUAL SYMBOL)
;       (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;       (CHECK-TYPE RACER::ABOX RACER::ABOX)
;       (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;       (RACER::POSSIBLY-COUNT-ONLY
;        (LOOP RACER::FOR NRQL-SYMBOLS:CONSTRAINT RACER::IN (RACER::INDIVIDUAL-INCOMING-ROLE-ASSERTIONS
;                                                            (RACER::FIND-INDIVIDUAL
;                                                             RACER::ABOX
;                                                             RACER::INDIVIDUAL))
;              RACER::COLLECT `((,# ,#) ,(RACER::ROLE-NAME #)))
;        COUNT))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:ALL-ROLE-ASSERTIONS-FOR-INDIVIDUAL-IN-RANGE
;         (RACER::INDIVIDUAL &OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*) &KEY
;          (COUNT NIL))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:ALL-ROLE-ASSERTIONS-FOR-INDIVIDUAL-IN-RANGE
;         (CHECK-TYPE RACER::INDIVIDUAL SYMBOL)
;         (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;         (CHECK-TYPE RACER::ABOX RACER::ABOX)
;         (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;         (RACER::POSSIBLY-COUNT-ONLY
;          (LOOP RACER::FOR NRQL-SYMBOLS:CONSTRAINT RACER::IN (RACER::INDIVIDUAL-INCOMING-ROLE-ASSERTIONS
;                                                              #)
;                RACER::COLLECT `(# ,#))
;          COUNT)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (INDIVIDUAL &OPTIONAL (ABOX *CURRENT-ABOX*) &KEY (COUNT NIL))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN ALL-ROLE-ASSERTIONS
;     (DEFUN RACER:ALL-ROLE-ASSERTIONS
;            (&OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*) &KEY (COUNT NIL))
;       (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;       (CHECK-TYPE RACER::ABOX RACER::ABOX)
;       (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;       (RACER::POSSIBLY-COUNT-ONLY
;        (IF NIL
;            (APPEND (RACER::ABOX-ROLE-AXIOMS RACER::ABOX)
;                    (LOOP RACER::FOR RACER::SUBRGAPH RACER::IN #
;                          NCONC #))
;            (RACER::ABOX-ROLE-AXIOMS RACER::ABOX))
;        COUNT))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:ALL-ROLE-ASSERTIONS
;         (&OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*) &KEY (COUNT NIL))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:ALL-ROLE-ASSERTIONS
;         (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;         (CHECK-TYPE RACER::ABOX RACER::ABOX)
;         (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;         (RACER::POSSIBLY-COUNT-ONLY
;          (IF NIL
;              (APPEND # #)
;              (RACER::ABOX-ROLE-AXIOMS RACER::ABOX))
;          COUNT)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (ABOX *CURRENT-ABOX*) &KEY (COUNT NIL))

;     (RACER::ABOX-ROLE-AXIOMS RACER::ABOX)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::ABOX
; 
; note: deleting unreachable code

;     (RACER::ABOX-SUBGRAPHS RACER::ABOX)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::ABOX
; 
; note: deleting unreachable code

;     (RACER::SUBGRAPH-ENCODED-ROLE-AXIOMS RACER::SUBRGAPH)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::SUBRGAPH
; 
; note: deleting unreachable code

;     (RACER::CONSTRAINT-IND-1 RACER::ASSERTION)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::ASSERTION
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN ALL-ANNOTATION-ROLE-ASSERTIONS
;     (DEFUN RACER:ALL-ANNOTATION-ROLE-ASSERTIONS
;            (&OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*) &KEY (COUNT NIL))
;       (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;       (CHECK-TYPE RACER::ABOX RACER::ABOX)
;       (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;       (RACER::POSSIBLY-COUNT-ONLY
;        (RACER::ABOX-ANNOTATION-ROLE-AXIOMS RACER::ABOX) COUNT))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:ALL-ANNOTATION-ROLE-ASSERTIONS
;         (&OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*) &KEY (COUNT NIL))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:ALL-ANNOTATION-ROLE-ASSERTIONS
;         (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;         (CHECK-TYPE RACER::ABOX RACER::ABOX)
;         (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;         (RACER::POSSIBLY-COUNT-ONLY
;          (RACER::ABOX-ANNOTATION-ROLE-AXIOMS RACER::ABOX) COUNT)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (ABOX *CURRENT-ABOX*) &KEY (COUNT NIL))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN ALL-ATTRIBUTE-ASSERTIONS
;     (DEFUN RACER:ALL-ATTRIBUTE-ASSERTIONS
;            (
;             &OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*)
;             (RACER::INDIVIDUAL NIL RACER::INDIVIDUAL-SUPPLIED-P)
;             &KEY (COUNT NIL))
;       (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;       (CHECK-TYPE RACER::ABOX RACER::ABOX)
;       (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;       (RACER::POSSIBLY-COUNT-ONLY
;        (IF RACER::INDIVIDUAL-SUPPLIED-P
;            (RACER::INDIVIDUAL-ATTRIBUTE-ASSERTIONS
;             (RACER::FIND-INDIVIDUAL RACER::ABOX RACER::INDIVIDUAL))
;            (REVERSE
;             (LOOP RACER::FOR # RACER::IN #
;                   RACER::COLLECT `#)))
;        COUNT))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:ALL-ATTRIBUTE-ASSERTIONS
;         (&OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*)
;          (RACER::INDIVIDUAL NIL RACER::INDIVIDUAL-SUPPLIED-P) &KEY (COUNT NIL))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:ALL-ATTRIBUTE-ASSERTIONS
;         (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;         (CHECK-TYPE RACER::ABOX RACER::ABOX)
;         (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;         (RACER::POSSIBLY-COUNT-ONLY
;          (IF RACER::INDIVIDUAL-SUPPLIED-P
;              (RACER::INDIVIDUAL-ATTRIBUTE-ASSERTIONS #)
;              (REVERSE #))
;          COUNT)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (ABOX *CURRENT-ABOX*) (INDIVIDUAL NIL INDIVIDUAL-SUPPLIED-P) &KEY (COUNT NIL))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN ALL-CONCEPT-ASSERTIONS
;     (DEFUN RACER:ALL-CONCEPT-ASSERTIONS
;            (&OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*) &KEY (COUNT NIL))
;       (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;       (CHECK-TYPE RACER::ABOX RACER::ABOX)
;       (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;       (RACER::POSSIBLY-COUNT-ONLY
;        (IF NIL
;            (LOOP RACER::FOR RACER::SUBRAPH RACER::IN (RACER::ABOX-SUBGRAPHS
;                                                       RACER::ABOX)
;                  NCONC (LOOP RACER::FOR RACER::ASSERTION RACER::IN #
;                              RACER::COLLECT #))
;            (RACER::ABOX-INDIVIDUAL-AXIOMS RACER::ABOX))
;        COUNT))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:ALL-CONCEPT-ASSERTIONS
;         (&OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*) &KEY (COUNT NIL))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:ALL-CONCEPT-ASSERTIONS
;         (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;         (CHECK-TYPE RACER::ABOX RACER::ABOX)
;         (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;         (RACER::POSSIBLY-COUNT-ONLY
;          (IF NIL
;              (LOOP RACER::FOR RACER::SUBRAPH RACER::IN #
;                    NCONC #)
;              (RACER::ABOX-INDIVIDUAL-AXIOMS RACER::ABOX))
;          COUNT)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (ABOX *CURRENT-ABOX*) &KEY (COUNT NIL))

;     (RACER::ABOX-SUBGRAPHS RACER::ABOX)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::ABOX
; 
; note: deleting unreachable code

;     (RACER::SUBGRAPH-ENCODED-INDIVIDUAL-AXIOMS RACER::SUBRAPH)
; --> SB-KERNEL:%INSTANCE-REF THE 
; ==>
;   RACER::SUBRAPH
; 
; note: deleting unreachable code

;     (FIRST RACER::ASSERTION)
; --> CAR 
; ==>
;   RACER::ASSERTION
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN ALL-ANNOTATION-CONCEPT-ASSERTIONS
;     (DEFUN RACER:ALL-ANNOTATION-CONCEPT-ASSERTIONS
;            (&OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*) &KEY (COUNT NIL))
;       (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;       (CHECK-TYPE RACER::ABOX RACER::ABOX)
;       (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;       (RACER::POSSIBLY-COUNT-ONLY
;        (RACER::ABOX-ANNOTATION-INDIVIDUAL-AXIOMS RACER::ABOX) COUNT))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:ALL-ANNOTATION-CONCEPT-ASSERTIONS
;         (&OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*) &KEY (COUNT NIL))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:ALL-ANNOTATION-CONCEPT-ASSERTIONS
;         (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;         (CHECK-TYPE RACER::ABOX RACER::ABOX)
;         (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;         (RACER::POSSIBLY-COUNT-ONLY
;          (RACER::ABOX-ANNOTATION-INDIVIDUAL-AXIOMS RACER::ABOX) COUNT)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (ABOX *CURRENT-ABOX*) &KEY (COUNT NIL))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN ALL-CONSTRAINTS
;     (DEFUN RACER:ALL-CONSTRAINTS
;            (
;             &OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*)
;             (RACER::OBJECT-NAMES NIL RACER::OBJECT-NAMES-SUPPLIED-P)
;             &KEY (COUNT NIL))
;       (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;       (CHECK-TYPE RACER::ABOX RACER::ABOX)
;       (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;       (RACER::POSSIBLY-COUNT-ONLY
;        (LET ((RACER:CONSTRAINTS #))
;          (IF RACER::OBJECT-NAMES-SUPPLIED-P
;              (LOOP RACER::FOR NRQL-SYMBOLS:CONSTRAINT RACER::IN RACER:CONSTRAINTS
;                    WHEN #
;                    RACER::COLLECT NRQL-SYMBOLS:CONSTRAINT)
;              RACER:CONSTRAINTS))
;        COUNT))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:ALL-CONSTRAINTS
;         (&OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*)
;          (RACER::OBJECT-NAMES NIL RACER::OBJECT-NAMES-SUPPLIED-P) &KEY
;          (COUNT NIL))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:ALL-CONSTRAINTS
;         (SETF RACER::ABOX (RACER:FIND-ABOX RACER::ABOX))
;         (CHECK-TYPE RACER::ABOX RACER::ABOX)
;         (RACER:ENSURE-KNOWLEDGE-BASE-STATE ':ABOX-PREPARED RACER::ABOX)
;         (RACER::POSSIBLY-COUNT-ONLY
;          (LET (#)
;            (IF RACER::OBJECT-NAMES-SUPPLIED-P
;                #
;                RACER:CONSTRAINTS))
;          COUNT)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (ABOX *CURRENT-ABOX*) (OBJECT-NAMES NIL OBJECT-NAMES-SUPPLIED-P) &KEY (COUNT NIL))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN PRINT-ABOX-RULE =>
;      DEFINE-RULE #S(SB-IMPL::COMMA :EXPR (FIRST (SWRL-RULE-HEAD RULE)) :KIND 0)
;     (RACER::SWRL-RULE-HEAD RACER::RULE)
; ==>
;   RACER::RULE
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN PRINT-ORIGINAL-ABOX
;     (RACER:RACER-WARN
;      "Abox memory savings option is enabled: no information is available for Abox ~S"
;      RACER::ABOX)
; ==>
;   "Abox memory savings option is enabled: no information is available for Abox ~S"
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN PRINT-ANONYMIZED-ABOX
;     (RACER:RACER-WARN
;      "Abox memory savings option is enabled: no information is available for Abox ~S"
;      RACER::ABOX)
; ==>
;   "Abox memory savings option is enabled: no information is available for Abox ~S"
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/abox.lisp
; in: DEFUN SAVE-ABOX
;     (DEFUN RACER:SAVE-ABOX
;            (RACER::PATHNAME-OR-STREAM
;             &OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*)
;             &KEY (RACER::SYNTAX :KRSS) (RACER::TRANSFORMED NIL)
;             (RACER::IF-EXISTS :SUPERSEDE) (RACER::IF-DOES-NOT-EXIST :CREATE)
;             (RACER::HEADER T) (RACER::URI NIL) (RACER::IMPORT-LIST NIL)
;             (RACER::ONTOLOGY-NAME NIL))
;       (CHECK-TYPE RACER::ABOX (OR SYMBOL RACER::ABOX))
;       (CHECK-TYPE RACER::SYNTAX (MEMBER :OWL :KRSS :RACE :TEST))
;       (CHECK-TYPE RACER::PATHNAME-OR-STREAM (OR PATHNAME STRING FILE-STREAM))
;       (FLET ((RACER::SAVE-ABOX-1 (RACER::ABOX STREAM)
;                (CASE RACER::SYNTAX # # #)))
;         (LET ((RACER::ABOX #))
;           (WHEN RACER::TRANSFORMED
;             (RACER:RACER-WARN
;              "Saving the ABox ~S in the transformed mode is currently not supported."
;              RACER::ABOX))
;           (RACER:ENSURE-KNOWLEDGE-BASE-STATE :ABOX-PREPARED RACER::ABOX)
;           (RACER::WITH-ABOX-SETTINGS RACER::ABOX
;             (RACER::WITH-CONCEPT-DEFINITION-MAPPING #
;               #)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER:SAVE-ABOX
;         (RACER::PATHNAME-OR-STREAM &OPTIONAL (RACER::ABOX RACER:*CURRENT-ABOX*)
;          &KEY (RACER::SYNTAX :KRSS) (RACER::TRANSFORMED NIL)
;          (RACER::IF-EXISTS :SUPERSEDE) (RACER::IF-DOES-NOT-EXIST :CREATE)
;          (RACER::HEADER T) (RACER::URI NIL) (RACER::IMPORT-LIST NIL)
;          (RACER::ONTOLOGY-NAME NIL))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER:SAVE-ABOX
;         (CHECK-TYPE RACER::ABOX (OR SYMBOL RACER::ABOX))
;         (CHECK-TYPE RACER::SYNTAX (MEMBER :OWL :KRSS :RACE :TEST))
;         (CHECK-TYPE RACER::PATHNAME-OR-STREAM (OR PATHNAME STRING FILE-STREAM))
;         (FLET ((RACER::SAVE-ABOX-1 #
;                  #))
;           (LET (#)
;             (WHEN RACER::TRANSFORMED #)
;             (RACER:ENSURE-KNOWLEDGE-BASE-STATE :ABOX-PREPARED RACER::ABOX)
;             (RACER::WITH-ABOX-SETTINGS RACER::ABOX
;               #)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (PATHNAME-OR-STREAM &OPTIONAL (ABOX *CURRENT-ABOX*) &KEY (SYNTAX :KRSS) (TRANSFORMED NIL) (IF-EXISTS :SUPERSEDE) (IF-DOES-NOT-EXIST :CREATE) (HEADER T) (URI NIL) (IMPORT-LIST NIL) (ONTOLOGY-NAME NIL))
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "racer" "racer-tools" "abox">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/utils.lisp
; in: DEFUN CREATE-DIRECTORY
;     (DEFUN RACER::CREATE-DIRECTORY (DIRECTORY) (ERROR "Not yet implemented."))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RACER::CREATE-DIRECTORY
;         (DIRECTORY)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK RACER::CREATE-DIRECTORY (ERROR "Not yet implemented.")))
; 
; caught STYLE-WARNING:
;   The variable DIRECTORY is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "racer" "utils">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/source/tools.lisp
; in: DEFUN STRING-SUBSTITUTE
;     (DEFUN THEMATIC-SUBSTRATE:STRING-SUBSTITUTE
;            (STRING
;             &OPTIONAL
;             (THEMATIC-SUBSTRATE::RULES THEMATIC-SUBSTRATE::*REPLACEMENTS*)
;             &KEY THEMATIC-SUBSTRATE::ADD-SPACES)
;       (LABELS ((THEMATIC-SUBSTRATE::DO-IT (STRING THEMATIC-SUBSTRATE::AKKU)
;                  (COND # #)))
;         (LET ((THEMATIC-SUBSTRATE::RES #))
;           (IF THEMATIC-SUBSTRATE::RES
;               (REDUCE #'# THEMATIC-SUBSTRATE::RES)
;               ""))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA THEMATIC-SUBSTRATE:STRING-SUBSTITUTE
;         (STRING &OPTIONAL
;                 (THEMATIC-SUBSTRATE::RULES THEMATIC-SUBSTRATE::*REPLACEMENTS*)
;                 &KEY THEMATIC-SUBSTRATE::ADD-SPACES)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK THEMATIC-SUBSTRATE:STRING-SUBSTITUTE
;         (LABELS ((THEMATIC-SUBSTRATE::DO-IT #
;                    #))
;           (LET (#)
;             (IF THEMATIC-SUBSTRATE::RES
;                 #
;                 "")))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (STRING &OPTIONAL (RULES *REPLACEMENTS*) &KEY ADD-SPACES)
; 
; caught ERROR:
;   READ error during COMPILE-FILE: Lock on package SB-FORMAT violated when interning *FORMAT-WHITESPACE-CHARS* while in package THEMATIC-SUBSTRATE.
;   See also:
;     The SBCL Manual, Node "Package Locks"(in form starting at line: 474, column: 0, position: 16036)
Unhandled UIOP/LISP-BUILD:COMPILE-FILE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING {10005305B3}>: COMPILE-FILE-ERROR while compiling #<CL-SOURCE-FILE "racer" "nrql" "tools">

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {10005305B3}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {1009996143}> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {1009996143}>)
2: (INVOKE-DEBUGGER #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {1009996143}>)
3: (ERROR UIOP/LISP-BUILD:COMPILE-FILE-ERROR :CONTEXT-FORMAT "~/asdf-action::format-action/" :CONTEXT-ARGUMENTS ((#<ASDF/LISP-ACTION:COMPILE-OP > . #<ASDF/LISP-ACTION:CL-SOURCE-FILE "racer" "nrql" "tools">)))
4: (UIOP/LISP-BUILD:CHECK-LISP-COMPILE-RESULTS NIL T T "~/asdf-action::format-action/" ((#<ASDF/LISP-ACTION:COMPILE-OP > . #<ASDF/LISP-ACTION:CL-SOURCE-FILE "racer" "nrql" "tools">)))
5: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "racer" "nrql" "tools">)
6: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
7: ((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS :AROUND (T T)) #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "racer" "nrql" "tools">) [fast-method]
8: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {100572D0A3}>) [fast-method]
9: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
10: ((:METHOD ASDF/PLAN:PERFORM-PLAN :AROUND (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {100572D0A3}>) [fast-method]
11: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "racer"> :PLAN-CLASS NIL :PLAN-OPTIONS NIL) [fast-method]
12: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "racer">)
13: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
14: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "racer">) [fast-method]
15: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "racer")
16: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
17: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "racer") [fast-method]
18: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {1005727B7B}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
19: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
20: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {10056E470B}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
21: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "racer") [fast-method]
22: (DEPCHECK::COMPUTE-DEPENDENCIES "racer" "racer")
23: (DEPCHECK::MAGIC "racer" "racer" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-UsRChJSG/depcheck-win.txt")
24: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "racer" "racer" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-UsRChJSG/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-UsRChJSG/depcheck-fail.txt"))
25: ((LAMBDA NIL :IN "/home/quicklisp/quicklisp/local-projects/quicklisp-controller/dumper-2SKVI5f7.lisp"))
26: ((FLET SB-UNIX::BODY :IN SAVE-LISP-AND-DIE))
27: ((FLET "WITHOUT-INTERRUPTS-BODY-27" :IN SAVE-LISP-AND-DIE))
28: ((LABELS SB-IMPL::RESTART-LISP :IN SAVE-LISP-AND-DIE))

unhandled condition in --disable-debugger mode, quitting
; 
; compilation unit aborted
;   caught 2 fatal ERROR conditions
;   caught 1 ERROR condition
;   caught 74 STYLE-WARNING conditions
;   printed 117 notes

lracer

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-core.lisp
; in: DEFUN READ-LINE-1
;     (RETURN-FROM RACER::READ-LINE-1 RACER::EOF-VALUE)
; ==>
;   RACER::EOF-VALUE
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN ALL-ANNOTATION-CONCEPT-ASSERTIONS
;     (DEFUN ALL-ANNOTATION-CONCEPT-ASSERTIONS
;            (
;             &OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;             &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ALL-ANNOTATION-CONCEPT-ASSERTIONS
;         (&OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P) &KEY
;          (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT))
;       (BLOCK ALL-ANNOTATION-CONCEPT-ASSERTIONS
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (ABOX NIL ABOX-SUPPLIED-P) &KEY (COUNT NIL COUNT-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN ALL-ANNOTATION-ROLE-ASSERTIONS
;     (DEFUN ALL-ANNOTATION-ROLE-ASSERTIONS
;            (
;             &OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;             &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ALL-ANNOTATION-ROLE-ASSERTIONS
;         (&OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P) &KEY
;          (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT))
;       (BLOCK ALL-ANNOTATION-ROLE-ASSERTIONS
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (ABOX NIL ABOX-SUPPLIED-P) &KEY (COUNT NIL COUNT-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN ALL-ATOMIC-CONCEPTS
;     (DEFUN ALL-ATOMIC-CONCEPTS
;            (
;             &OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P)
;             &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::TBOX COUNT))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ALL-ATOMIC-CONCEPTS
;         (&OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P) &KEY
;          (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::TBOX COUNT))
;       (BLOCK ALL-ATOMIC-CONCEPTS
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (TBOX NIL TBOX-SUPPLIED-P) &KEY (COUNT NIL COUNT-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN ALL-ATTRIBUTE-ASSERTIONS
;     (DEFUN ALL-ATTRIBUTE-ASSERTIONS
;            (
;             &OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;             (RACER::INDIVIDUAL NIL RACER::INDIVIDUAL-SUPPLIED-P)
;             &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::ABOX RACER::INDIVIDUAL COUNT))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ALL-ATTRIBUTE-ASSERTIONS
;         (&OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;          (RACER::INDIVIDUAL NIL RACER::INDIVIDUAL-SUPPLIED-P) &KEY
;          (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::ABOX RACER::INDIVIDUAL COUNT))
;       (BLOCK ALL-ATTRIBUTE-ASSERTIONS
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (ABOX NIL ABOX-SUPPLIED-P) (INDIVIDUAL NIL INDIVIDUAL-SUPPLIED-P) &KEY (COUNT NIL COUNT-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN ALL-ATTRIBUTES
;     (DEFUN ALL-ATTRIBUTES
;            (
;             &OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P)
;             &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::TBOX COUNT))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ALL-ATTRIBUTES
;         (&OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P) &KEY
;          (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::TBOX COUNT))
;       (BLOCK ALL-ATTRIBUTES
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (TBOX NIL TBOX-SUPPLIED-P) &KEY (COUNT NIL COUNT-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN ALL-CONCEPT-ASSERTIONS
;     (DEFUN ALL-CONCEPT-ASSERTIONS
;            (
;             &OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;             &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ALL-CONCEPT-ASSERTIONS
;         (&OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P) &KEY
;          (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT))
;       (BLOCK ALL-CONCEPT-ASSERTIONS
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (ABOX NIL ABOX-SUPPLIED-P) &KEY (COUNT NIL COUNT-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN ALL-CONCEPT-ASSERTIONS-FOR-INDIVIDUAL
;     (DEFUN ALL-CONCEPT-ASSERTIONS-FOR-INDIVIDUAL
;            (RACER::INDIVIDUAL
;             &OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;             &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT RACER::INDIVIDUAL))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ALL-CONCEPT-ASSERTIONS-FOR-INDIVIDUAL
;         (RACER::INDIVIDUAL &OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;          &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT RACER::INDIVIDUAL))
;       (BLOCK ALL-CONCEPT-ASSERTIONS-FOR-INDIVIDUAL
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (INDIVIDUAL &OPTIONAL (ABOX NIL ABOX-SUPPLIED-P) &KEY (COUNT NIL COUNT-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN ALL-CONSTRAINTS
;     (DEFUN ALL-CONSTRAINTS
;            (
;             &OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;             (RACER::OBJECT-NAMES NIL RACER::OBJECT-NAMES-SUPPLIED-P)
;             &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::ABOX RACER::OBJECT-NAMES COUNT))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ALL-CONSTRAINTS
;         (&OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;          (RACER::OBJECT-NAMES NIL RACER::OBJECT-NAMES-SUPPLIED-P) &KEY
;          (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::ABOX RACER::OBJECT-NAMES COUNT))
;       (BLOCK ALL-CONSTRAINTS
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (ABOX NIL ABOX-SUPPLIED-P) (OBJECT-NAMES NIL OBJECT-NAMES-SUPPLIED-P) &KEY (COUNT NIL COUNT-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN ALL-DIFFERENT-FROM-ASSERTIONS
;     (DEFUN ALL-DIFFERENT-FROM-ASSERTIONS
;            (
;             &OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;             &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ALL-DIFFERENT-FROM-ASSERTIONS
;         (&OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P) &KEY
;          (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT))
;       (BLOCK ALL-DIFFERENT-FROM-ASSERTIONS
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (ABOX NIL ABOX-SUPPLIED-P) &KEY (COUNT NIL COUNT-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN ALL-EQUIVALENT-CONCEPTS
;     (DEFUN ALL-EQUIVALENT-CONCEPTS
;            (
;             &OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P)
;             &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::TBOX COUNT))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ALL-EQUIVALENT-CONCEPTS
;         (&OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P) &KEY
;          (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::TBOX COUNT))
;       (BLOCK ALL-EQUIVALENT-CONCEPTS
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (TBOX NIL TBOX-SUPPLIED-P) &KEY (COUNT NIL COUNT-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN ALL-FEATURES
;     (DEFUN ALL-FEATURES
;            (
;             &OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P)
;             &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::TBOX COUNT))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ALL-FEATURES
;         (&OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P) &KEY
;          (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::TBOX COUNT))
;       (BLOCK ALL-FEATURES
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (TBOX NIL TBOX-SUPPLIED-P) &KEY (COUNT NIL COUNT-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN ALL-INDIVIDUALS
;     (DEFUN ALL-INDIVIDUALS
;            (
;             &OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;             &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ALL-INDIVIDUALS
;         (&OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P) &KEY
;          (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT))
;       (BLOCK ALL-INDIVIDUALS
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (ABOX NIL ABOX-SUPPLIED-P) &KEY (COUNT NIL COUNT-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN ALL-ROLE-ASSERTIONS
;     (DEFUN ALL-ROLE-ASSERTIONS
;            (
;             &OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;             &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ALL-ROLE-ASSERTIONS
;         (&OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P) &KEY
;          (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT))
;       (BLOCK ALL-ROLE-ASSERTIONS
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (ABOX NIL ABOX-SUPPLIED-P) &KEY (COUNT NIL COUNT-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN ALL-ROLE-ASSERTIONS-FOR-INDIVIDUAL-IN-DOMAIN
;     (DEFUN ALL-ROLE-ASSERTIONS-FOR-INDIVIDUAL-IN-DOMAIN
;            (RACER::INDIVIDUAL
;             &OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;             &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT RACER::INDIVIDUAL))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ALL-ROLE-ASSERTIONS-FOR-INDIVIDUAL-IN-DOMAIN
;         (RACER::INDIVIDUAL &OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;          &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT RACER::INDIVIDUAL))
;       (BLOCK ALL-ROLE-ASSERTIONS-FOR-INDIVIDUAL-IN-DOMAIN
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (INDIVIDUAL &OPTIONAL (ABOX NIL ABOX-SUPPLIED-P) &KEY (COUNT NIL COUNT-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN ALL-ROLE-ASSERTIONS-FOR-INDIVIDUAL-IN-RANGE
;     (DEFUN ALL-ROLE-ASSERTIONS-FOR-INDIVIDUAL-IN-RANGE
;            (RACER::INDIVIDUAL
;             &OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;             &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT RACER::INDIVIDUAL))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ALL-ROLE-ASSERTIONS-FOR-INDIVIDUAL-IN-RANGE
;         (RACER::INDIVIDUAL &OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;          &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT RACER::INDIVIDUAL))
;       (BLOCK ALL-ROLE-ASSERTIONS-FOR-INDIVIDUAL-IN-RANGE
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (INDIVIDUAL &OPTIONAL (ABOX NIL ABOX-SUPPLIED-P) &KEY (COUNT NIL COUNT-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN ALL-ROLES
;     (DEFUN ALL-ROLES
;            (
;             &OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P)
;             &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P)
;             (RACER::TEST NIL RACER::TEST-SUPPLIED-P)
;             (RACER::INVERSE-TEST NIL RACER::INVERSE-TEST-SUPPLIED-P)
;             (DEFAULT NIL RACER::DEFAULT-SUPPLIED-P))
;       (DECLARE
;        (IGNORABLE RACER::TBOX COUNT RACER::TEST RACER::INVERSE-TEST DEFAULT))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ALL-ROLES
;         (&OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P) &KEY
;          (COUNT NIL RACER::COUNT-SUPPLIED-P)
;          (RACER::TEST NIL RACER::TEST-SUPPLIED-P)
;          (RACER::INVERSE-TEST NIL RACER::INVERSE-TEST-SUPPLIED-P)
;          (DEFAULT NIL RACER::DEFAULT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE
;        (IGNORABLE RACER::TBOX COUNT RACER::TEST RACER::INVERSE-TEST DEFAULT))
;       (BLOCK ALL-ROLES
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (TBOX NIL TBOX-SUPPLIED-P) &KEY (COUNT NIL COUNT-SUPPLIED-P) (TEST NIL TEST-SUPPLIED-P) (INVERSE-TEST NIL INVERSE-TEST-SUPPLIED-P) (DEFAULT NIL DEFAULT-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN ALL-SAME-AS-ASSERTIONS
;     (DEFUN ALL-SAME-AS-ASSERTIONS
;            (
;             &OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;             &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ALL-SAME-AS-ASSERTIONS
;         (&OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P) &KEY
;          (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::ABOX COUNT))
;       (BLOCK ALL-SAME-AS-ASSERTIONS
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (ABOX NIL ABOX-SUPPLIED-P) &KEY (COUNT NIL COUNT-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN ALL-TRANSITIVE-ROLES
;     (DEFUN ALL-TRANSITIVE-ROLES
;            (
;             &OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P)
;             &KEY (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::TBOX COUNT))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ALL-TRANSITIVE-ROLES
;         (&OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P) &KEY
;          (COUNT NIL RACER::COUNT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::TBOX COUNT))
;       (BLOCK ALL-TRANSITIVE-ROLES
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (TBOX NIL TBOX-SUPPLIED-P) &KEY (COUNT NIL COUNT-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN CHECK-TBOX-COHERENCE
;     (DEFUN CHECK-TBOX-COHERENCE
;            (
;             &OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P)
;             &KEY (STREAM NIL RACER::STREAM-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::TBOX STREAM))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CHECK-TBOX-COHERENCE
;         (&OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P) &KEY
;          (STREAM NIL RACER::STREAM-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::TBOX STREAM))
;       (BLOCK CHECK-TBOX-COHERENCE
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (TBOX NIL TBOX-SUPPLIED-P) &KEY (STREAM NIL STREAM-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN DESCRIBE-ALL-QUERIES
;     (DEFUN DESCRIBE-ALL-QUERIES
;            (
;             &OPTIONAL (RACER::REWRITTEN-P NIL RACER::REWRITTEN-P-SUPPLIED-P)
;             &KEY (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;             (RACER::TYPE-OF-SUBSTRATE NIL RACER::TYPE-OF-SUBSTRATE-SUPPLIED-P))
;       (DECLARE
;        (IGNORABLE RACER::REWRITTEN-P RACER::ABOX RACER::TYPE-OF-SUBSTRATE))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA DESCRIBE-ALL-QUERIES
;         (&OPTIONAL (RACER::REWRITTEN-P NIL RACER::REWRITTEN-P-SUPPLIED-P) &KEY
;          (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;          (RACER::TYPE-OF-SUBSTRATE NIL RACER::TYPE-OF-SUBSTRATE-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE
;        (IGNORABLE RACER::REWRITTEN-P RACER::ABOX RACER::TYPE-OF-SUBSTRATE))
;       (BLOCK DESCRIBE-ALL-QUERIES
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (REWRITTEN-P NIL REWRITTEN-P-SUPPLIED-P) &KEY (ABOX NIL ABOX-SUPPLIED-P) (TYPE-OF-SUBSTRATE NIL TYPE-OF-SUBSTRATE-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN DESCRIBE-ALL-RULES
;     (DEFUN DESCRIBE-ALL-RULES
;            (
;             &OPTIONAL (RACER::REWRITTEN-P NIL RACER::REWRITTEN-P-SUPPLIED-P)
;             &KEY (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;             (RACER::TYPE-OF-SUBSTRATE NIL RACER::TYPE-OF-SUBSTRATE-SUPPLIED-P))
;       (DECLARE
;        (IGNORABLE RACER::REWRITTEN-P RACER::ABOX RACER::TYPE-OF-SUBSTRATE))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA DESCRIBE-ALL-RULES
;         (&OPTIONAL (RACER::REWRITTEN-P NIL RACER::REWRITTEN-P-SUPPLIED-P) &KEY
;          (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;          (RACER::TYPE-OF-SUBSTRATE NIL RACER::TYPE-OF-SUBSTRATE-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE
;        (IGNORABLE RACER::REWRITTEN-P RACER::ABOX RACER::TYPE-OF-SUBSTRATE))
;       (BLOCK DESCRIBE-ALL-RULES
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (REWRITTEN-P NIL REWRITTEN-P-SUPPLIED-P) &KEY (ABOX NIL ABOX-SUPPLIED-P) (TYPE-OF-SUBSTRATE NIL TYPE-OF-SUBSTRATE-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN GET-ABOX-GRAPH
;     (DEFUN GET-ABOX-GRAPH
;            (
;             &OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;             &KEY (RACER::DEPTH NIL RACER::DEPTH-SUPPLIED-P)
;             (RACER::NO-TRANSITIVES-P NIL RACER::NO-TRANSITIVES-P-SUPPLIED-P)
;             (RACER::NO-TOP-ROLE-P NIL RACER::NO-TOP-ROLE-P-SUPPLIED-P)
;             (RACER::BROWSING-MODE-P NIL RACER::BROWSING-MODE-P-SUPPLIED-P)
;             (RACER::TOLD-ONLY-P NIL RACER::TOLD-ONLY-P-SUPPLIED-P)
;             (RACER::ROOT-INDIVIDUALS NIL RACER::ROOT-INDIVIDUALS-SUPPLIED-P)
;             (RACER::SELECTED-INDIVIDUALS
;              NIL
;              RACER::SELECTED-INDIVIDUALS-SUPPLIED-P)
;             (RACER::ONLY-SUCCESSORS-IN-SELECTED-INDIVIDUALS-P
;              NIL
;              RACER::ONLY-SUCCESSORS-IN-SELECTED-INDIVIDUALS-P-SUPPLIED-P)
;             (RACER::FOR-ROLES NIL RACER::FOR-ROLES-SUPPLIED-P) ...)
;       (DECLARE
;        (IGNORABLE RACER::ABOX RACER::DEPTH RACER::NO-TRANSITIVES-P
;         RACER::NO-TOP-ROLE-P RACER::BROWSING-MODE-P RACER::TOLD-ONLY-P
;         RACER::ROOT-INDIVIDUALS RACER::SELECTED-INDIVIDUALS
;         RACER::ONLY-SUCCESSORS-IN-SELECTED-INDIVIDUALS-P RACER::FOR-ROLES
;         RACER::FOR-DATATYPE-PROPERTIES ...))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA GET-ABOX-GRAPH
;         (&OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P) &KEY
;          (RACER::DEPTH NIL RACER::DEPTH-SUPPLIED-P)
;          (RACER::NO-TRANSITIVES-P NIL RACER::NO-TRANSITIVES-P-SUPPLIED-P)
;          (RACER::NO-TOP-ROLE-P NIL RACER::NO-TOP-ROLE-P-SUPPLIED-P)
;          (RACER::BROWSING-MODE-P NIL RACER::BROWSING-MODE-P-SUPPLIED-P)
;          (RACER::TOLD-ONLY-P NIL RACER::TOLD-ONLY-P-SUPPLIED-P)
;          (RACER::ROOT-INDIVIDUALS NIL RACER::ROOT-INDIVIDUALS-SUPPLIED-P)
;          (RACER::SELECTED-INDIVIDUALS NIL
;           RACER::SELECTED-INDIVIDUALS-SUPPLIED-P)
;          (RACER::ONLY-SUCCESSORS-IN-SELECTED-INDIVIDUALS-P NIL
;           RACER::ONLY-SUCCESSORS-IN-SELECTED-INDIVIDUALS-P-SUPPLIED-P)
;          (RACER::FOR-ROLES NIL RACER::FOR-ROLES-SUPPLIED-P) ...)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE
;        (IGNORABLE RACER::ABOX RACER::DEPTH RACER::NO-TRANSITIVES-P
;         RACER::NO-TOP-ROLE-P RACER::BROWSING-MODE-P RACER::TOLD-ONLY-P
;         RACER::ROOT-INDIVIDUALS RACER::SELECTED-INDIVIDUALS
;         RACER::ONLY-SUCCESSORS-IN-SELECTED-INDIVIDUALS-P RACER::FOR-ROLES
;         RACER::FOR-DATATYPE-PROPERTIES ...))
;       (BLOCK GET-ABOX-GRAPH
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (ABOX NIL ABOX-SUPPLIED-P) &KEY (DEPTH NIL DEPTH-SUPPLIED-P) (NO-TRANSITIVES-P NIL NO-TRANSITIVES-P-SUPPLIED-P) (NO-TOP-ROLE-P NIL NO-TOP-ROLE-P-SUPPLIED-P) (BROWSING-MODE-P NIL BROWSING-MODE-P-SUPPLIED-P) (TOLD-ONLY-P NIL TOLD-ONLY-P-SUPPLIED-P) (ROOT-INDIVIDUALS NIL ROOT-INDIVIDUALS-SUPPLIED-P) (SELECTED-INDIVIDUALS NIL SELECTED-INDIVIDUALS-SUPPLIED-P) (ONLY-SUCCESSORS-IN-SELECTED-INDIVIDUALS-P NIL ONLY-SUCCESSORS-IN-SELECTED-INDIVIDUALS-P-SUPPLIED-P) (FOR-ROLES NIL FOR-ROLES-SUPPLIED-P) (FOR-DATATYPE-PROPERTIES NIL FOR-DATATYPE-PROPERTIES-SUPPLIED-P) (FOR-ANNOTATION-PROPERTIES NIL FOR-ANNOTATION-PROPERTIES-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN GET-CONCEPT-PROPERTIES
;     (DEFUN GET-CONCEPT-PROPERTIES
;            (RACER::CONCEPT
;             &OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P)
;             &KEY (RACER::FOR-ROLES NIL RACER::FOR-ROLES-SUPPLIED-P)
;             (RACER::QUALIFICATIONS NIL RACER::QUALIFICATIONS-SUPPLIED-P))
;       (DECLARE
;        (IGNORABLE RACER::TBOX RACER::FOR-ROLES RACER::QUALIFICATIONS
;         RACER::CONCEPT))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA GET-CONCEPT-PROPERTIES
;         (RACER::CONCEPT &OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P) &KEY
;          (RACER::FOR-ROLES NIL RACER::FOR-ROLES-SUPPLIED-P)
;          (RACER::QUALIFICATIONS NIL RACER::QUALIFICATIONS-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE
;        (IGNORABLE RACER::TBOX RACER::FOR-ROLES RACER::QUALIFICATIONS
;         RACER::CONCEPT))
;       (BLOCK GET-CONCEPT-PROPERTIES
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (CONCEPT &OPTIONAL (TBOX NIL TBOX-SUPPLIED-P) &KEY (FOR-ROLES NIL FOR-ROLES-SUPPLIED-P) (QUALIFICATIONS NIL QUALIFICATIONS-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN GET-NEXT-N-REMAINING-TUPLES
;     (DEFUN GET-NEXT-N-REMAINING-TUPLES
;            (QUERY
;             &OPTIONAL (RACER::N NIL RACER::N-SUPPLIED-P)
;             &KEY (RACER::EXECUTE-P NIL RACER::EXECUTE-P-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::N RACER::EXECUTE-P QUERY))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA GET-NEXT-N-REMAINING-TUPLES
;         (QUERY &OPTIONAL (RACER::N NIL RACER::N-SUPPLIED-P) &KEY
;          (RACER::EXECUTE-P NIL RACER::EXECUTE-P-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::N RACER::EXECUTE-P QUERY))
;       (BLOCK GET-NEXT-N-REMAINING-TUPLES
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (QUERY &OPTIONAL (N NIL N-SUPPLIED-P) &KEY (EXECUTE-P NIL EXECUTE-P-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN GET-ROLE-HIERARCHY
;     (DEFUN GET-ROLE-HIERARCHY
;            (
;             &OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P)
;             &KEY (RACER::FOR-ROLES NIL RACER::FOR-ROLES-SUPPLIED-P))
;       (DECLARE (IGNORABLE RACER::TBOX RACER::FOR-ROLES))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA GET-ROLE-HIERARCHY
;         (&OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P) &KEY
;          (RACER::FOR-ROLES NIL RACER::FOR-ROLES-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (IGNORABLE RACER::TBOX RACER::FOR-ROLES))
;       (BLOCK GET-ROLE-HIERARCHY
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (TBOX NIL TBOX-SUPPLIED-P) &KEY (FOR-ROLES NIL FOR-ROLES-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN SAVE-ABOX
;     (DEFUN SAVE-ABOX
;            (RACER::PATHNAME-OR-STREAM
;             &OPTIONAL (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P)
;             &KEY (RACER::SYNTAX NIL RACER::SYNTAX-SUPPLIED-P)
;             (RACER::TRANSFORMED NIL RACER::TRANSFORMED-SUPPLIED-P)
;             (RACER::IF-EXISTS NIL RACER::IF-EXISTS-SUPPLIED-P)
;             (RACER::IF-DOES-NOT-EXIST NIL RACER::IF-DOES-NOT-EXIST-SUPPLIED-P)
;             (RACER::HEADER NIL RACER::HEADER-SUPPLIED-P)
;             (RACER::URI NIL RACER::URI-SUPPLIED-P)
;             (RACER::IMPORT-LIST NIL RACER::IMPORT-LIST-SUPPLIED-P)
;             (RACER::ONTOLOGY-NAME NIL RACER::ONTOLOGY-NAME-SUPPLIED-P))
;       (DECLARE
;        (IGNORABLE RACER::ABOX RACER::SYNTAX RACER::TRANSFORMED RACER::IF-EXISTS
;         RACER::IF-DOES-NOT-EXIST RACER::HEADER RACER::URI RACER::IMPORT-LIST
;         RACER::ONTOLOGY-NAME RACER::PATHNAME-OR-STREAM))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA SAVE-ABOX
;         (RACER::PATHNAME-OR-STREAM &OPTIONAL
;          (RACER::ABOX NIL RACER::ABOX-SUPPLIED-P) &KEY
;          (RACER::SYNTAX NIL RACER::SYNTAX-SUPPLIED-P)
;          (RACER::TRANSFORMED NIL RACER::TRANSFORMED-SUPPLIED-P)
;          (RACER::IF-EXISTS NIL RACER::IF-EXISTS-SUPPLIED-P)
;          (RACER::IF-DOES-NOT-EXIST NIL RACER::IF-DOES-NOT-EXIST-SUPPLIED-P)
;          (RACER::HEADER NIL RACER::HEADER-SUPPLIED-P)
;          (RACER::URI NIL RACER::URI-SUPPLIED-P)
;          (RACER::IMPORT-LIST NIL RACER::IMPORT-LIST-SUPPLIED-P)
;          (RACER::ONTOLOGY-NAME NIL RACER::ONTOLOGY-NAME-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE
;        (IGNORABLE RACER::ABOX RACER::SYNTAX RACER::TRANSFORMED RACER::IF-EXISTS
;         RACER::IF-DOES-NOT-EXIST RACER::HEADER RACER::URI RACER::IMPORT-LIST
;         RACER::ONTOLOGY-NAME RACER::PATHNAME-OR-STREAM))
;       (BLOCK SAVE-ABOX
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (PATHNAME-OR-STREAM &OPTIONAL (ABOX NIL ABOX-SUPPLIED-P) &KEY (SYNTAX NIL SYNTAX-SUPPLIED-P) (TRANSFORMED NIL TRANSFORMED-SUPPLIED-P) (IF-EXISTS NIL IF-EXISTS-SUPPLIED-P) (IF-DOES-NOT-EXIST NIL IF-DOES-NOT-EXIST-SUPPLIED-P) (HEADER NIL HEADER-SUPPLIED-P) (URI NIL URI-SUPPLIED-P) (IMPORT-LIST NIL IMPORT-LIST-SUPPLIED-P) (ONTOLOGY-NAME NIL ONTOLOGY-NAME-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN SAVE-TBOX
;     (DEFUN SAVE-TBOX
;            (RACER::PATHNAME-OR-STREAM
;             &OPTIONAL (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P)
;             &KEY (RACER::SYNTAX NIL RACER::SYNTAX-SUPPLIED-P)
;             (RACER::TRANSFORMED NIL RACER::TRANSFORMED-SUPPLIED-P)
;             (RACER::AVOID-DUPLICATE-DEFINITIONS
;              NIL
;              RACER::AVOID-DUPLICATE-DEFINITIONS-SUPPLIED-P)
;             (RACER::IF-EXISTS NIL RACER::IF-EXISTS-SUPPLIED-P)
;             (RACER::IF-DOES-NOT-EXIST NIL RACER::IF-DOES-NOT-EXIST-SUPPLIED-P)
;             (RACER::URI NIL RACER::URI-SUPPLIED-P)
;             (RACER::ANONYMIZED NIL RACER::ANONYMIZED-SUPPLIED-P)
;             (RACER::HEADER NIL RACER::HEADER-SUPPLIED-P))
;       (DECLARE
;        (IGNORABLE RACER::TBOX RACER::SYNTAX RACER::TRANSFORMED
;         RACER::AVOID-DUPLICATE-DEFINITIONS RACER::IF-EXISTS
;         RACER::IF-DOES-NOT-EXIST RACER::URI RACER::ANONYMIZED RACER::HEADER
;         RACER::PATHNAME-OR-STREAM))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           (RACER::SERVICE-REQUEST RACER::REQ-STRING))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA SAVE-TBOX
;         (RACER::PATHNAME-OR-STREAM &OPTIONAL
;          (RACER::TBOX NIL RACER::TBOX-SUPPLIED-P) &KEY
;          (RACER::SYNTAX NIL RACER::SYNTAX-SUPPLIED-P)
;          (RACER::TRANSFORMED NIL RACER::TRANSFORMED-SUPPLIED-P)
;          (RACER::AVOID-DUPLICATE-DEFINITIONS NIL
;           RACER::AVOID-DUPLICATE-DEFINITIONS-SUPPLIED-P)
;          (RACER::IF-EXISTS NIL RACER::IF-EXISTS-SUPPLIED-P)
;          (RACER::IF-DOES-NOT-EXIST NIL RACER::IF-DOES-NOT-EXIST-SUPPLIED-P)
;          (RACER::URI NIL RACER::URI-SUPPLIED-P)
;          (RACER::ANONYMIZED NIL RACER::ANONYMIZED-SUPPLIED-P)
;          (RACER::HEADER NIL RACER::HEADER-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE
;        (IGNORABLE RACER::TBOX RACER::SYNTAX RACER::TRANSFORMED
;         RACER::AVOID-DUPLICATE-DEFINITIONS RACER::IF-EXISTS
;         RACER::IF-DOES-NOT-EXIST RACER::URI RACER::ANONYMIZED RACER::HEADER
;         RACER::PATHNAME-OR-STREAM))
;       (BLOCK SAVE-TBOX
;         (RACER::WITH-STANDARD-IO-SYNTAX-1
;           (LET (#)
;             (RACER::SERVICE-REQUEST RACER::REQ-STRING)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (PATHNAME-OR-STREAM &OPTIONAL (TBOX NIL TBOX-SUPPLIED-P) &KEY (SYNTAX NIL SYNTAX-SUPPLIED-P) (TRANSFORMED NIL TRANSFORMED-SUPPLIED-P) (AVOID-DUPLICATE-DEFINITIONS NIL AVOID-DUPLICATE-DEFINITIONS-SUPPLIED-P) (IF-EXISTS NIL IF-EXISTS-SUPPLIED-P) (IF-DOES-NOT-EXIST NIL IF-DOES-NOT-EXIST-SUPPLIED-P) (URI NIL URI-SUPPLIED-P) (ANONYMIZED NIL ANONYMIZED-SUPPLIED-P) (HEADER NIL HEADER-SUPPLIED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFMACRO GET-RACER-VERSION
;     (DEFMACRO GET-RACER-VERSION ()
;       (DECLARE (IGNORABLE))
;       (RACER::WITH-STANDARD-IO-SYNTAX-1
;         (LET ((RACER::REQ-STRING #))
;           `(RACER::SERVICE-REQUEST ,RACER::REQ-STRING))))
; --> PROGN EVAL-WHEN 
; ==>
;   (SB-C::%DEFMACRO 'GET-RACER-VERSION
;                    (SB-INT:NAMED-LAMBDA (MACRO-FUNCTION GET-RACER-VERSION)
;                        (#:EXPR #:ENV)
;                      (DECLARE (SB-C::LAMBDA-LIST NIL))
;                      (DECLARE (IGNORE #:ENV))
;                      (SB-INT:NAMED-DS-BIND (:MACRO GET-RACER-VERSION . DEFMACRO)
;                          NIL
;                          (CDR #:EXPR)
;                        (DECLARE (IGNORABLE))
;                        (BLOCK GET-RACER-VERSION
;                          (RACER::WITH-STANDARD-IO-SYNTAX-1
;                            #))))
;                    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   GET-RACER-VERSION is being redefined as a macro when it was previously defined to be a function.
; 
; caught STYLE-WARNING:
;   redefining RACER:GET-RACER-VERSION in DEFMACRO

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/racer/d096f21c46d8b4d1499a2d2e3eadadd81f06fb01/racer-20181201-git/clients/lracer/lracer-stubs.lisp
; in: DEFUN EXIT-SERVER
;     (HANDLER-CASE
;      (RACER::WITH-STANDARD-IO-SYNTAX-1
;        (LET ((RACER::REQ-STRING #))
;          (RACER::SERVICE-REQUEST RACER::REQ-STRING)))
;      (RACER::RACER-ERROR (ERROR) (ERROR ERROR))
;      (RACER::LRACER-CONNECTION-ERROR (ERROR) T))
; --> SB-INT:DX-FLET FLET 
; ==>
;   (#:FUN3 (ERROR) (PROGN T))
; 
; caught STYLE-WARNING:
;   The variable ERROR is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "lracer" "lracer-stubs">
; 
; caught ERROR:
;   READ error during COMPILE-FILE: Lock on package SB-FORMAT violated when interning *FORMAT-WHITESPACE-CHARS* while in package RACER.
;   See also:
;     The SBCL Manual, Node "Package Locks"(in form starting at line: 57, column: 0, position: 1352)
Unhandled UIOP/LISP-BUILD:COMPILE-FILE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING {10005305B3}>: COMPILE-FILE-ERROR while compiling #<CL-SOURCE-FILE "lracer" "lracer-reader-macros">

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {10005305B3}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {100D0721D3}> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {100D0721D3}>)
2: (INVOKE-DEBUGGER #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {100D0721D3}>)
3: (ERROR UIOP/LISP-BUILD:COMPILE-FILE-ERROR :CONTEXT-FORMAT "~/asdf-action::format-action/" :CONTEXT-ARGUMENTS ((#<ASDF/LISP-ACTION:COMPILE-OP > . #<ASDF/LISP-ACTION:CL-SOURCE-FILE "lracer" "lracer-reader-macros">)))
4: (UIOP/LISP-BUILD:CHECK-LISP-COMPILE-RESULTS NIL T T "~/asdf-action::format-action/" ((#<ASDF/LISP-ACTION:COMPILE-OP > . #<ASDF/LISP-ACTION:CL-SOURCE-FILE "lracer" "lracer-reader-macros">)))
5: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "lracer" "lracer-reader-macros">)
6: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
7: ((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS :AROUND (T T)) #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "lracer" "lracer-reader-macros">) [fast-method]
8: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1005BCF8E3}>) [fast-method]
9: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
10: ((:METHOD ASDF/PLAN:PERFORM-PLAN :AROUND (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1005BCF8E3}>) [fast-method]
11: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "lracer"> :PLAN-CLASS NIL :PLAN-OPTIONS NIL) [fast-method]
12: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "lracer">)
13: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
14: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "lracer">) [fast-method]
15: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "lracer")
16: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
17: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "lracer") [fast-method]
18: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {1005BC2DEB}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
19: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
20: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {1005B7D27B}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
21: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "lracer") [fast-method]
22: (DEPCHECK::COMPUTE-DEPENDENCIES "lracer" "lracer")
23: (DEPCHECK::MAGIC "lracer" "lracer" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-r8JGWLIm/depcheck-win.txt")
24: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "lracer" "lracer" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-r8JGWLIm/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-r8JGWLIm/depcheck-fail.txt"))
25: ((LAMBDA NIL :IN "/home/quicklisp/quicklisp/local-projects/quicklisp-controller/dumper-2SKVI5f7.lisp"))
26: ((FLET SB-UNIX::BODY :IN SAVE-LISP-AND-DIE))
27: ((FLET "WITHOUT-INTERRUPTS-BODY-27" :IN SAVE-LISP-AND-DIE))
28: ((LABELS SB-IMPL::RESTART-LISP :IN SAVE-LISP-AND-DIE))

unhandled condition in --disable-debugger mode, quitting
; 
; compilation unit aborted
;   caught 2 fatal ERROR conditions
;   caught 1 ERROR condition
;   caught 30 STYLE-WARNING conditions
;   printed 1 note