gsharp

SBCL 1.4.4 / ASDF 3.3.1

gsharp

WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/trivial-garbage/8edc182c56fc03da3a83f6fb26d446c6f381abec/trivial-garbage-20180205-git/trivial-garbage.asd" contains definition for system "trivial-garbage-tests". Please only define "trivial-garbage" and secondary systems with a name starting with "trivial-garbage/" (e.g. "trivial-garbage/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/flexi-streams/d08cfa551a2f185431304236cd56db2fbb98b864/flexi-streams-20180205-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: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/ieee-floats/fa9e496f0fcf4ba05754fc32787f728ca6e2d674/ieee-floats-20180205-git/ieee-floats.asd" contains definition for system "ieee-floats-tests". Please only define "ieee-floats" and secondary systems with a name starting with "ieee-floats/" (e.g. "ieee-floats/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Extensions/bezier/mcclim-bezier.asd" contains definition for system "mcclim-bezier-core". Please only define "mcclim-bezier" and secondary systems with a name starting with "mcclim-bezier/" (e.g. "mcclim-bezier/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Extensions/bezier/mcclim-bezier.asd" contains definition for system "mcclim-bezier-clx". Please only define "mcclim-bezier" and secondary systems with a name starting with "mcclim-bezier/" (e.g. "mcclim-bezier/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-fad/c651a53bfe4663b51bce20ffdc29f380f4c70408/cl-fad-20180205-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/puri/7e3394cbc337b808a0ecbbedfebe1b5f21f5f46c/puri-20180205-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/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-xml". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-dom". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-klacks". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-test". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: redefining COMMON-LISP:OUTPUT-STREAM-P in DEFGENERIC
WARNING: redefining OUTPUT-STREAM-P (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-basic/regions.lisp
; in: DEFUN %ELLIPSE-SIMPLIFIED-REPRESENTATION/RADIUS
;     (COS CLIM-INTERNALS::BASE-ANGLE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.

;     (SIN CLIM-INTERNALS::BASE-ANGLE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.

;     (* CLIM-INTERNALS::MXX CLIM-INTERNALS::X)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a (OR (SINGLE-FLOAT -1.0 1.0) (DOUBLE-FLOAT -1.0d0 1.0d0) (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a (OR (SINGLE-FLOAT -1.0 1.0) (DOUBLE-FLOAT -1.0d0 1.0d0) (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (* CLIM-INTERNALS::MXY CLIM-INTERNALS::Y)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a (OR (SINGLE-FLOAT -1.0 1.0) (DOUBLE-FLOAT -1.0d0 1.0d0) (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a (OR (SINGLE-FLOAT -1.0 1.0) (DOUBLE-FLOAT -1.0d0 1.0d0) (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (+ (* CLIM-INTERNALS::MXX CLIM-INTERNALS::X)
;        (* CLIM-INTERNALS::MXY CLIM-INTERNALS::Y) CLIM-INTERNALS::TX)
; --> + 
; ==>
;   (+ (* CLIM-INTERNALS::MXX CLIM-INTERNALS::X)
;      (* CLIM-INTERNALS::MXY CLIM-INTERNALS::Y))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; ==>
;   (+
;    (+ (* CLIM-INTERNALS::MXX CLIM-INTERNALS::X)
;       (* CLIM-INTERNALS::MXY CLIM-INTERNALS::Y))
;    CLIM-INTERNALS::TX)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (* CLIM-INTERNALS::MYX CLIM-INTERNALS::X)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a (OR (SINGLE-FLOAT -1.0 1.0) (DOUBLE-FLOAT -1.0d0 1.0d0) (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a (OR (SINGLE-FLOAT -1.0 1.0) (DOUBLE-FLOAT -1.0d0 1.0d0) (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (* CLIM-INTERNALS::MYY CLIM-INTERNALS::Y)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a (OR (SINGLE-FLOAT -1.0 1.0) (DOUBLE-FLOAT -1.0d0 1.0d0) (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a (OR (SINGLE-FLOAT -1.0 1.0) (DOUBLE-FLOAT -1.0d0 1.0d0) (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (+ (* CLIM-INTERNALS::MYX CLIM-INTERNALS::X)
;        (* CLIM-INTERNALS::MYY CLIM-INTERNALS::Y) CLIM-INTERNALS::TY)
; --> + 
; ==>
;   (+ (* CLIM-INTERNALS::MYX CLIM-INTERNALS::X)
;      (* CLIM-INTERNALS::MYY CLIM-INTERNALS::Y))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; ==>
;   (+
;    (+ (* CLIM-INTERNALS::MYX CLIM-INTERNALS::X)
;       (* CLIM-INTERNALS::MYY CLIM-INTERNALS::Y))
;    CLIM-INTERNALS::TY)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Backends/PostScript/sheet.lisp
; in: DEFMETHOD NEW-PAGE (POSTSCRIPT-STREAM)
;     (SETF (SLOT-VALUE STREAM 'CLIM-INTERNALS::OUTPUT-HISTORY)
;             CLIM-POSTSCRIPT::HISTORY
;           (CLIM:STREAM-CURRENT-OUTPUT-RECORD STREAM) CLIM-POSTSCRIPT::HISTORY)
; 
; note: Cannot optimize slot access, inheritance of #<STANDARD-CLASS CLIM-POSTSCRIPT::POSTSCRIPT-STREAM> is not yet finalizable due to forward-referenced superclasses:
;   (SB-PCL::SET-SLOT-VALUE STREAM (QUOTE CLIM-INTERNALS::OUTPUT-HISTORY) HISTORY)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/bordered-output.lisp
; in: DEFMETHOD REPLAY-OUTPUT-RECORD :BEFORE (BORDERED-OUTPUT-RECORD T)
;     (DEFMETHOD CLIM:REPLAY-OUTPUT-RECORD :BEFORE
;                ((CLIM-INTERNALS::BORDER CLIM-EXTENSIONS:BORDERED-OUTPUT-RECORD)
;                 STREAM
;                 &OPTIONAL CLIM:REGION (CLIM-INTERNALS::X-OFFSET 0)
;                 (CLIM-INTERNALS::Y-OFFSET 0))
;       (CLIM:CLEAR-OUTPUT-RECORD CLIM-INTERNALS::BORDER)
;       (CLIM-INTERNALS::%PREPARE-BORDERED-OUTPUT-RECORD CLIM-INTERNALS::BORDER))
; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA (SB-PCL::FAST-METHOD CLIM:REPLAY-OUTPUT-RECORD :BEFORE
;                           (CLIM-EXTENSIONS:BORDERED-OUTPUT-RECORD T))
;         (SB-PCL::.PV. SB-PCL::.NEXT-METHOD-CALL. CLIM-INTERNALS::BORDER STREAM
;          &OPTIONAL CLIM:REGION (CLIM-INTERNALS::X-OFFSET 0)
;          (CLIM-INTERNALS::Y-OFFSET 0))
;       (DECLARE (IGNORABLE SB-PCL::.PV. SB-PCL::.NEXT-METHOD-CALL.)
;                (DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
;       (DECLARE (SB-PCL::%PARAMETER STREAM))
;       (DECLARE (SB-PCL::%PARAMETER CLIM-INTERNALS::BORDER))
;       (DECLARE (TYPE T STREAM))
;       (DECLARE (IGNORABLE STREAM CLIM-INTERNALS::BORDER))
;       (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
;         (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ((CLIM-INTERNALS::BORDER STREAM)
;                                                 SB-PCL::.NEXT-METHOD-CALL.
;                                                 (CLIM-INTERNALS::BORDER STREAM)
;                                                 NIL :CALL-NEXT-METHOD-P NIL
;                                                 :SETQ-P NIL :PARAMETERS-SETQD
;                                                 NIL :METHOD-CELL
;                                                 (#:METHOD-CELL) ...)
;           (DECLARE
;            (SB-PCL::%CLASS CLIM-INTERNALS::BORDER
;             CLIM-EXTENSIONS:BORDERED-OUTPUT-RECORD))
;           (LOCALLY
;            (DECLARE #)
;            (SYMBOL-MACROLET #
;              #
;              #)))))
; 
; caught STYLE-WARNING:
;   The variable REGION is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable X-OFFSET is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable Y-OFFSET is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "clim-core" "bordered-output">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE NIL))
;                                      (DECLARE (IGNORE CLIM-INTERNALS::OBJECT))
;                                      NIL)
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::NIL)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((DECLARE (IGNORE CLIM-INTERNALS::OBJECT))
;                                 (BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::NIL)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE NULL))
;                                      (EQ CLIM-INTERNALS::OBJECT NIL))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::NULL)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::NULL)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT (TYPE NULL) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::OBJECT
;                                        CLIM-INTERNALS::ACCEPTABLY
;                                        CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (WRITE-STRING "None" STREAM))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::NULL)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::OBJECT
;                                   CLIM-INTERNALS::ACCEPTABLY
;                                   CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::NULL)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD ACCEPT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:ACCEPT
;                                      ((TYPE NULL) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                      (VALUES
;                                       (CLIM:COMPLETING-FROM-SUGGESTIONS (STREAM)
;                                         (CLIM:SUGGEST "None" NIL)
;                                         (CLIM:SUGGEST "" NIL))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%ACCEPT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::NULL)|)
;                                 TYPE STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                ((BLOCK CLIM:ACCEPT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::NULL)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE BOOLEAN))
;                                      (OR (EQ CLIM-INTERNALS::OBJECT T)
;                                          (EQ CLIM-INTERNALS::OBJECT NIL)))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::BOOLEAN)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::BOOLEAN)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT (TYPE BOOLEAN)
;                                       STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                        CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (IF CLIM-INTERNALS::OBJECT
;                                          (WRITE-STRING "Yes" STREAM)
;                                          (WRITE-STRING "No" STREAM)))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::BOOLEAN)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                   CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::BOOLEAN)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD ACCEPT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:ACCEPT
;                                      ((TYPE BOOLEAN) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                      (CLIM-INTERNALS::ACCEPT-USING-COMPLETION
;                                       'BOOLEAN STREAM
;                                       #'(LAMBDA
;                                             (CLIM-INTERNALS::INPUT-STRING
;                                              CLIM-INTERNALS::MODE)
;                                           (CLIM:COMPLETE-FROM-POSSIBILITIES
;                                            CLIM-INTERNALS::INPUT-STRING '(# #)
;                                            NIL :ACTION CLIM-INTERNALS::MODE))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%ACCEPT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::BOOLEAN)|)
;                                 TYPE STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                ((BLOCK CLIM:ACCEPT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::BOOLEAN)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE SYMBOL))
;                                      (SYMBOLP CLIM-INTERNALS::OBJECT))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::SYMBOL)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::SYMBOL)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT (TYPE SYMBOL) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (IF CLIM-INTERNALS::ACCEPTABLY
;                                          (PRIN1 CLIM-INTERNALS::OBJECT STREAM)
;                                          (PRINC CLIM-INTERNALS::OBJECT STREAM)))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::SYMBOL)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::SYMBOL)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD ACCEPT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:ACCEPT
;                                      ((TYPE SYMBOL) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       (CLIM-INTERNALS::DEFAULT-TYPE TYPE)
;                                       CLIM-INTERNALS::DEFAULT)
;                                      (LET ((CLIM-INTERNALS::READ-RESULT
;                                             (CLIM-INTERNALS::ACCEPT-USING-READ
;                                              STREAM TYPE)))
;                                        (IF (AND
;                                             (NULL CLIM-INTERNALS::READ-RESULT)
;                                             CLIM-INTERNALS::DEFAULT)
;                                            (VALUES CLIM-INTERNALS::DEFAULT
;                                                    CLIM-INTERNALS::DEFAULT-TYPE)
;                                            (VALUES CLIM-INTERNALS::READ-RESULT
;                                                    TYPE))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%ACCEPT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::SYMBOL)|)
;                                 TYPE STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 (CLIM-INTERNALS::DEFAULT-TYPE TYPE)
;                                 CLIM-INTERNALS::DEFAULT)
;                                ((BLOCK CLIM:ACCEPT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::SYMBOL)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE KEYWORD))
;                                      (KEYWORDP CLIM-INTERNALS::OBJECT))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::KEYWORD)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::KEYWORD)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT (TYPE KEYWORD)
;                                       STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                        CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (PRIN1 CLIM-INTERNALS::OBJECT STREAM))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::KEYWORD)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                   CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::KEYWORD)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD HIGHLIGHT-PRESENTATION
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:HIGHLIGHT-PRESENTATION
;                                      ((TYPE CLIM:BLANK-AREA)
;                                       CLIM-INTERNALS::RECORD STREAM
;                                       CLIM-INTERNALS::STATE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::RECORD STREAM
;                                        CLIM-INTERNALS::STATE))
;                                      NIL)
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%HIGHLIGHT-PRESENTATION NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::BLANK-AREA)|)
;                                 TYPE CLIM-INTERNALS::RECORD STREAM
;                                 CLIM-INTERNALS::STATE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::RECORD STREAM
;                                   CLIM-INTERNALS::STATE))
;                                 (BLOCK CLIM:HIGHLIGHT-PRESENTATION
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::BLANK-AREA)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE NUMBER))
;                                      (NUMBERP CLIM-INTERNALS::OBJECT))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::NUMBER)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::NUMBER)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE COMPLEX))
;                                      (AND (COMPLEXP CLIM-INTERNALS::OBJECT)
;                                           (TYPEP
;                                            (REALPART CLIM-INTERNALS::OBJECT)
;                                            TYPE)
;                                           (TYPEP
;                                            (IMAGPART CLIM-INTERNALS::OBJECT)
;                                            TYPE)))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::COMPLEX)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::COMPLEX)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT (TYPE COMPLEX)
;                                       STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                        CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (CLIM:PRESENT
;                                       (REALPART CLIM-INTERNALS::OBJECT)
;                                       (CLIM:PRESENTATION-TYPE-OF
;                                        (REALPART CLIM-INTERNALS::OBJECT))
;                                       :STREAM STREAM :VIEW CLIM:VIEW :SENSITIVE
;                                       NIL)
;                                      (WRITE-CHAR #\  STREAM)
;                                      (CLIM:PRESENT
;                                       (IMAGPART CLIM-INTERNALS::OBJECT)
;                                       (CLIM:PRESENTATION-TYPE-OF
;                                        (IMAGPART CLIM-INTERNALS::OBJECT))
;                                       :STREAM STREAM :VIEW CLIM:VIEW :SENSITIVE
;                                       NIL))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::COMPLEX)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                   CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::COMPLEX)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE REAL))
;                                      (AND (REALP CLIM-INTERNALS::OBJECT)
;                                           (OR (EQ CLIM-INTERNALS::LOW '*)
;                                               (<= CLIM-INTERNALS::LOW
;                                                   CLIM-INTERNALS::OBJECT))
;                                           (OR (EQ CLIM-INTERNALS::HIGH '*)
;                                               (<= CLIM-INTERNALS::OBJECT
;                                                   CLIM-INTERNALS::HIGH))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::REAL)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::REAL)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT (TYPE REAL) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                        CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (LET ((*PRINT-BASE* CLIM-INTERNALS::BASE)
;                                            (*PRINT-RADIX* CLIM-INTERNALS::RADIX))
;                                        (PRINC CLIM-INTERNALS::OBJECT STREAM)))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::REAL)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                   CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::REAL)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD ACCEPT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:ACCEPT
;                                      ((TYPE REAL) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       (CLIM-INTERNALS::DEFAULT-TYPE TYPE)
;                                       CLIM-INTERNALS::DEFAULT)
;                                      (LET ((*READ-BASE* CLIM-INTERNALS::BASE)
;                                            (CLIM-INTERNALS::READ-RESULT
;                                             (CLIM-INTERNALS::ACCEPT-USING-READ
;                                              STREAM TYPE)))
;                                        (IF (AND
;                                             (NULL CLIM-INTERNALS::READ-RESULT)
;                                             CLIM-INTERNALS::DEFAULT)
;                                            (VALUES CLIM-INTERNALS::DEFAULT
;                                                    CLIM-INTERNALS::DEFAULT-TYPE)
;                                            (VALUES CLIM-INTERNALS::READ-RESULT
;                                                    TYPE))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%ACCEPT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::REAL)|)
;                                 TYPE STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 (CLIM-INTERNALS::DEFAULT-TYPE TYPE)
;                                 CLIM-INTERNALS::DEFAULT)
;                                ((BLOCK CLIM:ACCEPT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::REAL)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE RATIONAL))
;                                      (AND (RATIONALP CLIM-INTERNALS::OBJECT)
;                                           (OR (EQ CLIM-INTERNALS::LOW '*)
;                                               (<= CLIM-INTERNALS::LOW
;                                                   CLIM-INTERNALS::OBJECT))
;                                           (OR (EQ CLIM-INTERNALS::HIGH '*)
;                                               (<= CLIM-INTERNALS::OBJECT
;                                                   CLIM-INTERNALS::HIGH))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::RATIONAL)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::RATIONAL)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT (TYPE RATIONAL)
;                                       STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                        CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (LET ((*PRINT-BASE* CLIM-INTERNALS::BASE)
;                                            (*PRINT-RADIX* CLIM-INTERNALS::RADIX))
;                                        (PRINC CLIM-INTERNALS::OBJECT STREAM)))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::RATIONAL)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                   CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::RATIONAL)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE INTEGER))
;                                      (AND (INTEGERP CLIM-INTERNALS::OBJECT)
;                                           (OR (EQ CLIM-INTERNALS::LOW '*)
;                                               (<= CLIM-INTERNALS::LOW
;                                                   CLIM-INTERNALS::OBJECT))
;                                           (OR (EQ CLIM-INTERNALS::HIGH '*)
;                                               (<= CLIM-INTERNALS::OBJECT
;                                                   CLIM-INTERNALS::HIGH))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::INTEGER)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::INTEGER)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT (TYPE INTEGER)
;                                       STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                        CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (LET ((*PRINT-BASE* CLIM-INTERNALS::BASE)
;                                            (*PRINT-RADIX* CLIM-INTERNALS::RADIX))
;                                        (PRINC CLIM-INTERNALS::OBJECT STREAM)))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::INTEGER)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                   CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::INTEGER)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE RATIO))
;                                      (AND (NOT (INTEGERP CLIM-INTERNALS::OBJECT))
;                                           (RATIONALP CLIM-INTERNALS::OBJECT)
;                                           (OR (EQ CLIM-INTERNALS::LOW '*)
;                                               (<= CLIM-INTERNALS::LOW
;                                                   CLIM-INTERNALS::OBJECT))
;                                           (OR (EQ CLIM-INTERNALS::HIGH '*)
;                                               (<= CLIM-INTERNALS::OBJECT
;                                                   CLIM-INTERNALS::HIGH))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::RATIO)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::RATIO)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT (TYPE RATIO) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                        CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (LET ((*PRINT-BASE* CLIM-INTERNALS::BASE)
;                                            (*PRINT-RADIX* CLIM-INTERNALS::RADIX))
;                                        (PRINC CLIM-INTERNALS::OBJECT STREAM)))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::RATIO)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                   CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::RATIO)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE FLOAT))
;                                      (AND (FLOATP CLIM-INTERNALS::OBJECT)
;                                           (OR (EQ CLIM-INTERNALS::LOW '*)
;                                               (<= CLIM-INTERNALS::LOW
;                                                   CLIM-INTERNALS::OBJECT))
;                                           (OR (EQ CLIM-INTERNALS::HIGH '*)
;                                               (<= CLIM-INTERNALS::OBJECT
;                                                   CLIM-INTERNALS::HIGH))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::FLOAT)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::FLOAT)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT (TYPE FLOAT) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                        CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (LET ((*PRINT-BASE* CLIM-INTERNALS::BASE)
;                                            (*PRINT-RADIX* CLIM-INTERNALS::RADIX))
;                                        (PRINC CLIM-INTERNALS::OBJECT STREAM)))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::FLOAT)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                   CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::FLOAT)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE CHARACTER))
;                                      (CHARACTERP CLIM-INTERNALS::OBJECT))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::CHARACTER)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::CHARACTER)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT (TYPE CHARACTER)
;                                       STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                        CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (PRINC CLIM-INTERNALS::OBJECT STREAM))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::CHARACTER)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                   CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::CHARACTER)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE STRING))
;                                      (AND (STRINGP CLIM-INTERNALS::OBJECT)
;                                           (OR (EQ LENGTH '*)
;                                               (EQL
;                                                (LENGTH CLIM-INTERNALS::OBJECT)
;                                                LENGTH))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::STRING)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::STRING)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT (TYPE STRING) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (IF CLIM-INTERNALS::ACCEPTABLY
;                                          (PRIN1 CLIM-INTERNALS::OBJECT STREAM)
;                                          (PRINC CLIM-INTERNALS::OBJECT STREAM)))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::STRING)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::STRING)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD ACCEPT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:ACCEPT
;                                      ((TYPE STRING) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       (CLIM-INTERNALS::DEFAULT NIL
;                                        CLIM-INTERNALS::DEFAULTP)
;                                       (CLIM-INTERNALS::DEFAULT-TYPE TYPE))
;                                      (LET ((CLIM-INTERNALS::RESULT
;                                             (CLIM:READ-TOKEN STREAM)))
;                                        (COND
;                                         ((NUMBERP LENGTH)
;                                          (IF #
;                                              #
;                                              #))
;                                         ((AND # CLIM-INTERNALS::DEFAULTP)
;                                          (VALUES CLIM-INTERNALS::DEFAULT
;                                                  CLIM-INTERNALS::DEFAULT-TYPE))
;                                         (T
;                                          (VALUES CLIM-INTERNALS::RESULT TYPE)))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%ACCEPT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::STRING)|)
;                                 TYPE STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 (CLIM-INTERNALS::DEFAULT NIL
;                                  CLIM-INTERNALS::DEFAULTP)
;                                 (CLIM-INTERNALS::DEFAULT-TYPE TYPE))
;                                ((BLOCK CLIM:ACCEPT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::STRING)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE PATHNAME))
;                                      (PATHNAMEP CLIM-INTERNALS::OBJECT))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::PATHNAME)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::PATHNAME)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      ((CLIM-INTERNALS::OBJECT PATHNAME)
;                                       (TYPE PATHNAME) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                      (LET ((PATHNAME
;                                             (IF #
;                                                 CLIM-INTERNALS::OBJECT
;                                                 #)))
;                                        (DECLARE (IGNORE PATHNAME))
;                                        (PRINC CLIM-INTERNALS::OBJECT STREAM)))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::PATHNAME)|)
;                                 (CLIM-INTERNALS::OBJECT PATHNAME) TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                ((BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::PATHNAME)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      ((CLIM-INTERNALS::OBJECT STRING)
;                                       (TYPE PATHNAME) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &REST
;                                       CLIM-INTERNALS::ARGS &KEY)
;                                      (CLIM:APPLY-PRESENTATION-GENERIC-FUNCTION
;                                       CLIM:PRESENT
;                                       (PATHNAME CLIM-INTERNALS::OBJECT) TYPE
;                                       STREAM CLIM:VIEW CLIM-INTERNALS::ARGS))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::PATHNAME)|)
;                                 (CLIM-INTERNALS::OBJECT STRING) TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &REST
;                                 CLIM-INTERNALS::ARGS &KEY)
;                                ((BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::PATHNAME)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD ACCEPT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:ACCEPT
;                                      ((TYPE PATHNAME) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       (CLIM-INTERNALS::DEFAULT
;                                        *DEFAULT-PATHNAME-DEFAULTS*
;                                        CLIM-INTERNALS::DEFAULTP)
;                                       ((:DEFAULT-TYPE
;                                         CLIM-INTERNALS::ACCEPT-DEFAULT-TYPE)
;                                        TYPE))
;                                      (MULTIPLE-VALUE-BIND
;                                          (PATHNAME CLIM-INTERNALS::SUCCESS
;                                                    STRING)
;                                          (CLIM:COMPLETE-INPUT STREAM
;                                                               #'CLIM-INTERNALS::FILENAME-COMPLETER
;                                                               :ALLOW-ANY-INPUT T)
;                                        (COND
;                                         ((AND PATHNAME CLIM-INTERNALS::SUCCESS)
;                                          (VALUES # TYPE))
;                                         ((AND # CLIM-INTERNALS::DEFAULTP)
;                                          (VALUES CLIM-INTERNALS::DEFAULT
;                                                  CLIM-INTERNALS::ACCEPT-DEFAULT-TYPE))
;                                         (T (VALUES STRING 'STRING)))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%ACCEPT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::PATHNAME)|)
;                                 TYPE STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 (CLIM-INTERNALS::DEFAULT
;                                  *DEFAULT-PATHNAME-DEFAULTS*
;                                  CLIM-INTERNALS::DEFAULTP)
;                                 ((:DEFAULT-TYPE
;                                   CLIM-INTERNALS::ACCEPT-DEFAULT-TYPE)
;                                  TYPE))
;                                ((BLOCK CLIM:ACCEPT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::PATHNAME)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT
;                                       (TYPE CLIM:COMPLETION))
;                                      (MAP NIL
;                                           #'(LAMBDA (CLIM-INTERNALS::OBJ)
;                                               (WHEN
;                                                   (FUNCALL CLIM-INTERNALS::TEST
;                                                            CLIM-INTERNALS::OBJECT
;                                                            #)
;                                                 (RETURN-FROM
;                                                     CLIM:PRESENTATION-TYPEP
;                                                   T)))
;                                           SEQUENCE)
;                                      NIL)
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::COMPLETION)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::COMPLETION)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT
;                                       (TYPE CLIM:COMPLETION) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                        CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (LET ((CLIM-INTERNALS::OBJ-POS
;                                             (POSITION CLIM-INTERNALS::OBJECT
;                                                       SEQUENCE :TEST
;                                                       CLIM-INTERNALS::TEST :KEY
;                                                       CLIM-INTERNALS::VALUE-KEY)))
;                                        (IF CLIM-INTERNALS::OBJ-POS
;                                            (WRITE-STRING
;                                             (FUNCALL CLIM-INTERNALS::NAME-KEY #)
;                                             STREAM)
;                                            (ERROR
;                                             "~S is not of presentation type ~S"
;                                             CLIM-INTERNALS::OBJECT TYPE))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::COMPLETION)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                   CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::COMPLETION)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD ACCEPT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:ACCEPT
;                                      ((TYPE CLIM:COMPLETION) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                      (CLIM-INTERNALS::ACCEPT-USING-COMPLETION
;                                       (CLIM:MAKE-PRESENTATION-TYPE-SPECIFIER
;                                        `(CLIM:COMPLETION
;                                          ,@CLIM-INTERNALS::PARAMETERS)
;                                        CLIM-INTERNALS::OPTIONS)
;                                       STREAM
;                                       #'(LAMBDA
;                                             (CLIM-INTERNALS::INPUT-STRING
;                                              CLIM-INTERNALS::MODE)
;                                           (CLIM:COMPLETE-FROM-POSSIBILITIES
;                                            CLIM-INTERNALS::INPUT-STRING SEQUENCE
;                                            CLIM-INTERNALS::PARTIAL-COMPLETERS
;                                            :ACTION CLIM-INTERNALS::MODE :NAME-KEY
;                                            CLIM-INTERNALS::NAME-KEY :VALUE-KEY
;                                            CLIM-INTERNALS::VALUE-KEY))
;                                       :PARTIAL-COMPLETERS
;                                       CLIM-INTERNALS::PARTIAL-COMPLETERS))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%ACCEPT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::COMPLETION)|)
;                                 TYPE STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                ((BLOCK CLIM:ACCEPT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::COMPLETION)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT
;                                       (TYPE CLIM:SUBSET-COMPLETION))
;                                      (MAP NIL
;                                           #'(LAMBDA (CLIM-INTERNALS::OBJ)
;                                               (UNLESS
;                                                   (FIND CLIM-INTERNALS::OBJ
;                                                         SEQUENCE :TEST
;                                                         CLIM-INTERNALS::TEST :KEY
;                                                         CLIM-INTERNALS::VALUE-KEY)
;                                                 (RETURN-FROM
;                                                     CLIM:PRESENTATION-TYPEP
;                                                   NIL)))
;                                           CLIM-INTERNALS::OBJECT)
;                                      T)
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::SUBSET-COMPLETION)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::SUBSET-COMPLETION)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      ((CLIM-INTERNALS::OBJECT LIST)
;                                       (TYPE CLIM:SUBSET-COMPLETION) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (LOOP CLIM-INTERNALS::FOR CLIM-INTERNALS::TAIL CLIM-INTERNALS::ON CLIM-INTERNALS::OBJECT
;                                            CLIM-INTERNALS::FOR (CLIM-INTERNALS::OBJ) = CLIM-INTERNALS::TAIL
;                                            DO (PROGN
;                                                (CLIM:PRESENT CLIM-INTERNALS::OBJ
;                                                 (CLIM:PRESENTATION-TYPE-OF
;                                                  CLIM-INTERNALS::OBJECT)
;                                                 :STREAM STREAM :VIEW CLIM:VIEW
;                                                 :ACCEPTABLY
;                                                 CLIM-INTERNALS::ACCEPTABLY
;                                                 :SENSITIVE NIL)
;                                                (WHEN (CDR CLIM-INTERNALS::TAIL)
;                                                  (IF CLIM-INTERNALS::ACCEPTABLY
;                                                      #
;                                                      #)))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::SUBSET-COMPLETION)|)
;                                 (CLIM-INTERNALS::OBJECT LIST) TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::SUBSET-COMPLETION)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      ((CLIM-INTERNALS::OBJECT VECTOR)
;                                       (TYPE CLIM:SUBSET-COMPLETION) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (LOOP CLIM-INTERNALS::FOR CLIM-INTERNALS::I CLIM-INTERNALS::FROM 0 CLIM-INTERNALS::BELOW (LENGTH
;                                                                                                                                CLIM-INTERNALS::OBJECT)
;                                            CLIM-INTERNALS::FOR CLIM-INTERNALS::OBJ = (AREF
;                                                                                       CLIM-INTERNALS::OBJECT
;                                                                                       CLIM-INTERNALS::I)
;                                            DO ...))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::SUBSET-COMPLETION)|)
;                                 (CLIM-INTERNALS::OBJECT VECTOR) TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::SUBSET-COMPLETION)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPE-SPECIFIER-P
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPE-SPECIFIER-P
;                                      ((TYPE SEQUENCE))
;                                      (AND (LISTP TYPE) (CONSP (REST TYPE))
;                                           (CLIM:PRESENTATION-TYPE-SPECIFIER-P
;                                            (SECOND TYPE))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPE-SPECIFIER-P
;                                NIL
;                                ((CLIM-INTERNALS::TYPE-CLASS
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::SEQUENCE)|)
;                                 TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPE-SPECIFIER-P
;                                   (AND (LISTP TYPE) (CONSP #)
;                                        (CLIM:PRESENTATION-TYPE-SPECIFIER-P
;                                         #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::SEQUENCE)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE SEQUENCE))
;                                      (UNLESS
;                                          (OR (LISTP CLIM-INTERNALS::OBJECT)
;                                              (VECTORP CLIM-INTERNALS::OBJECT))
;                                        (RETURN-FROM CLIM:PRESENTATION-TYPEP NIL))
;                                      (LET ((CLIM-INTERNALS::REAL-TYPE
;                                             (CLIM:EXPAND-PRESENTATION-TYPE-ABBREVIATION
;                                              TYPE)))
;                                        (MAP NIL
;                                             #'(LAMBDA (CLIM-INTERNALS::OBJ)
;                                                 (UNLESS # #))
;                                             CLIM-INTERNALS::OBJECT)
;                                        T))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::SEQUENCE)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::SEQUENCE)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      ((CLIM-INTERNALS::OBJECT LIST)
;                                       (TYPE SEQUENCE) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (LOOP CLIM-INTERNALS::FOR CLIM-INTERNALS::TAIL CLIM-INTERNALS::ON CLIM-INTERNALS::OBJECT
;                                            CLIM-INTERNALS::FOR (CLIM-INTERNALS::OBJ) = CLIM-INTERNALS::TAIL
;                                            DO (PROGN
;                                                (CLIM:PRESENT CLIM-INTERNALS::OBJ
;                                                 TYPE :STREAM STREAM :VIEW
;                                                 CLIM:VIEW :ACCEPTABLY
;                                                 CLIM-INTERNALS::ACCEPTABLY
;                                                 :SENSITIVE NIL)
;                                                (WHEN (CDR CLIM-INTERNALS::TAIL)
;                                                  (WRITE-CHAR
;                                                   CLIM-INTERNALS::SEPARATOR
;                                                   STREAM)))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::SEQUENCE)|)
;                                 (CLIM-INTERNALS::OBJECT LIST) TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::SEQUENCE)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      ((CLIM-INTERNALS::OBJECT VECTOR)
;                                       (TYPE SEQUENCE) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (LOOP CLIM-INTERNALS::FOR CLIM-INTERNALS::I CLIM-INTERNALS::FROM 0 CLIM-INTERNALS::BELOW (LENGTH
;                                                                                                                                CLIM-INTERNALS::OBJECT)
;                                            CLIM-INTERNALS::FOR CLIM-INTERNALS::OBJ = (AREF
;                                                                                       CLIM-INTERNALS::OBJECT
;                                                                                       CLIM-INTERNALS::I)
;                                            DO ...))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::SEQUENCE)|)
;                                 (CLIM-INTERNALS::OBJECT VECTOR) TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::SEQUENCE)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD ACCEPT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:ACCEPT
;                                      ((TYPE SEQUENCE) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                      (LOOP CLIM-INTERNALS::WITH CLIM-INTERNALS::SEPARATORS = (LIST
;                                                                                               CLIM-INTERNALS::SEPARATOR)
;                                            CLIM-INTERNALS::FOR CLIM-INTERNALS::ELEMENT = (CLIM:ACCEPT
;                                                                                           TYPE
;                                                                                           :STREAM
;                                                                                           STREAM
;                                                                                           :VIEW
;                                                                                           CLIM:VIEW
;                                                                                           :PROMPT
;                                                                                           NIL
;                                                                                           :ADDITIONAL-DELIMITER-GESTURES
;                                                                                           CLIM-INTERNALS::SEPARATORS)
;                                            CLIM-INTERNALS::COLLECT CLIM-INTERNALS::ELEMENT
;                                            DO ...))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%ACCEPT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::SEQUENCE)|)
;                                 TYPE STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                ((BLOCK CLIM:ACCEPT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::SEQUENCE)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT
;                                       (TYPE CLIM:SEQUENCE-ENUMERATED))
;                                      (UNLESS
;                                          (OR (LISTP CLIM-INTERNALS::OBJECT)
;                                              (VECTORP CLIM-INTERNALS::OBJECT))
;                                        (RETURN-FROM CLIM:PRESENTATION-TYPEP NIL))
;                                      (MAP NIL
;                                           #'(LAMBDA (CLIM-INTERNALS::OBJ TYPE)
;                                               (LET (#)
;                                                 (UNLESS # #)))
;                                           CLIM-INTERNALS::OBJECT
;                                           CLIM-INTERNALS::TYPES)
;                                      T)
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::SEQUENCE-ENUMERATED)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::SEQUENCE-ENUMERATED)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      ((CLIM-INTERNALS::OBJECT LIST)
;                                       (TYPE CLIM:SEQUENCE-ENUMERATED) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (LOOP CLIM-INTERNALS::FOR CLIM-INTERNALS::TAIL CLIM-INTERNALS::ON CLIM-INTERNALS::OBJECT
;                                            CLIM-INTERNALS::FOR (CLIM-INTERNALS::OBJ) = CLIM-INTERNALS::TAIL
;                                            CLIM-INTERNALS::FOR CLIM-INTERNALS::OBJ-TYPE CLIM-INTERNALS::IN ...))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::SEQUENCE-ENUMERATED)|)
;                                 (CLIM-INTERNALS::OBJECT LIST) TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::SEQUENCE-ENUMERATED)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      ((CLIM-INTERNALS::OBJECT VECTOR)
;                                       (TYPE CLIM:SEQUENCE-ENUMERATED) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (LOOP CLIM-INTERNALS::FOR CLIM-INTERNALS::I CLIM-INTERNALS::FROM 0 CLIM-INTERNALS::BELOW (LENGTH
;                                                                                                                                CLIM-INTERNALS::OBJECT)
;                                            CLIM-INTERNALS::FOR CLIM-INTERNALS::OBJ = (AREF
;                                                                                       CLIM-INTERNALS::OBJECT
;                                                                                       CLIM-INTERNALS::I)
;                                            CLIM-INTERNALS::FOR ...))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::SEQUENCE-ENUMERATED)|)
;                                 (CLIM-INTERNALS::OBJECT VECTOR) TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::SEQUENCE-ENUMERATED)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD ACCEPT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:ACCEPT
;                                      ((TYPE CLIM:SEQUENCE-ENUMERATED) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                      (LOOP CLIM-INTERNALS::WITH CLIM-INTERNALS::ELEMENT = NIL
;                                            AND CLIM-INTERNALS::ELEMENT-TYPE = NIL
;                                            AND CLIM-INTERNALS::SEPARATORS = ...))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%ACCEPT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::SEQUENCE-ENUMERATED)|)
;                                 TYPE STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                ((BLOCK CLIM:ACCEPT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::SEQUENCE-ENUMERATED)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE OR))
;                                      (LOOP CLIM-INTERNALS::FOR TYPE CLIM-INTERNALS::IN CLIM-INTERNALS::TYPES
;                                            CLIM-INTERNALS::FOR CLIM-INTERNALS::REAL-TYPE = (CLIM:EXPAND-PRESENTATION-TYPE-ABBREVIATION
;                                                                                             TYPE)
;                                            DO (WHEN
;                                                   (CLIM:PRESENTATION-TYPEP
;                                                    CLIM-INTERNALS::OBJECT
;                                                    CLIM-INTERNALS::REAL-TYPE)
;                                                 (RETURN-FROM
;                                                     CLIM:PRESENTATION-TYPEP
;                                                   T)))
;                                      NIL)
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::OR)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::OR)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT (TYPE OR) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (LOOP CLIM-INTERNALS::FOR CLIM-INTERNALS::OR-TYPE CLIM-INTERNALS::IN CLIM-INTERNALS::TYPES
;                                            CLIM-INTERNALS::FOR CLIM-INTERNALS::EXPANDED-TYPE = (CLIM:EXPAND-PRESENTATION-TYPE-ABBREVIATION
;                                                                                                 CLIM-INTERNALS::OR-TYPE)
;                                            DO (WHEN
;                                                   (CLIM:PRESENTATION-TYPEP
;                                                    CLIM-INTERNALS::OBJECT
;                                                    CLIM-INTERNALS::EXPANDED-TYPE)
;                                                 (CLIM:PRESENT
;                                                  CLIM-INTERNALS::OBJECT
;                                                  CLIM-INTERNALS::EXPANDED-TYPE
;                                                  :STREAM STREAM :VIEW CLIM:VIEW
;                                                  :ACCEPTABLY
;                                                  CLIM-INTERNALS::ACCEPTABLY
;                                                  :FOR-CONTEXT-TYPE
;                                                  CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                                 (LOOP-FINISH))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::OR)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::OR)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD ACCEPT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:ACCEPT
;                                      ((TYPE OR)
;                                       (STREAM CLIM:INPUT-EDITING-STREAM)
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                      (CLIM:WITH-INPUT-CONTEXT (TYPE)
;                                          (CLIM-INTERNALS::OBJECT
;                                           CLIM-INTERNALS::TYPE-VAR)
;                                          (LET ((CLIM-INTERNALS::STR #))
;                                            (LOOP CLIM-INTERNALS::FOR CLIM-INTERNALS::OR-TYPE CLIM-INTERNALS::IN CLIM-INTERNALS::TYPES
;                                                  DO (HANDLER-CASE # #)
;                                                  CLIM-INTERNALS::FINALLY (CLIM:SIMPLE-PARSE-ERROR
;                                                                           "Input type is not one of ~S"
;                                                                           CLIM-INTERNALS::TYPES)))
;                                        (T
;                                         (CLIM:PRESENTATION-REPLACE-INPUT STREAM
;                                                                          CLIM-INTERNALS::OBJECT
;                                                                          CLIM-INTERNALS::TYPE-VAR
;                                                                          CLIM:VIEW
;                                                                          :RESCAN
;                                                                          NIL)
;                                         (RETURN-FROM CLIM:ACCEPT
;                                           (VALUES CLIM-INTERNALS::OBJECT
;                                                   CLIM-INTERNALS::TYPE-VAR)))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%ACCEPT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::OR)|)
;                                 TYPE (STREAM CLIM:INPUT-EDITING-STREAM)
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                ((BLOCK CLIM:ACCEPT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::OR)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE AND))
;                                      (LOOP CLIM-INTERNALS::FOR TYPE CLIM-INTERNALS::IN CLIM-INTERNALS::TYPES
;                                            CLIM-INTERNALS::FOR CLIM-INTERNALS::REAL-TYPE = (CLIM:EXPAND-PRESENTATION-TYPE-ABBREVIATION
;                                                                                             TYPE)
;                                            DO (CLIM:WITH-PRESENTATION-TYPE-DECODED (CLIM-INTERNALS::NAME
;                                                                                     CLIM-INTERNALS::PARAMETERS)
;                                                   CLIM-INTERNALS::REAL-TYPE
;                                                 (COND (# #) (# #) (T #))))
;                                      T)
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::AND)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::AND)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT (TYPE AND) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (CLIM:PRESENT CLIM-INTERNALS::OBJECT
;                                       (CLIM:EXPAND-PRESENTATION-TYPE-ABBREVIATION
;                                        (CAR CLIM-INTERNALS::TYPES))
;                                       :STREAM STREAM :VIEW CLIM:VIEW :ACCEPTABLY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       :FOR-CONTEXT-TYPE
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::AND)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::AND)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD ACCEPT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:ACCEPT
;                                      ((TYPE AND)
;                                       (STREAM CLIM:INPUT-EDITING-STREAM)
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &REST
;                                       CLIM-INTERNALS::ARGS &KEY)
;                                      (LET ((CLIM-INTERNALS::SUBTYPE
;                                             (FIRST CLIM-INTERNALS::TYPES)))
;                                        (MULTIPLE-VALUE-BIND
;                                            (CLIM-INTERNALS::OBJ
;                                             CLIM-INTERNALS::PTYPE)
;                                            (CLIM:APPLY-PRESENTATION-GENERIC-FUNCTION
;                                             CLIM:ACCEPT CLIM-INTERNALS::SUBTYPE
;                                             STREAM CLIM:VIEW
;                                             CLIM-INTERNALS::ARGS)
;                                          (DECLARE (IGNORE CLIM-INTERNALS::PTYPE))
;                                          (UNLESS
;                                              (CLIM:PRESENTATION-TYPEP
;                                               CLIM-INTERNALS::OBJ TYPE)
;                                            (CLIM:SIMPLE-PARSE-ERROR
;                                             "Input object ~S is not of type ~S"
;                                             CLIM-INTERNALS::OBJ TYPE))
;                                          CLIM-INTERNALS::OBJ)))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%ACCEPT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::AND)|)
;                                 TYPE (STREAM CLIM:INPUT-EDITING-STREAM)
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &REST
;                                 CLIM-INTERNALS::ARGS &KEY)
;                                ((BLOCK CLIM:ACCEPT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::AND)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT
;                                       (TYPE CLIM:EXPRESSION))
;                                      (DECLARE (IGNORE CLIM-INTERNALS::OBJECT)) T)
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::EXPRESSION)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((DECLARE (IGNORE CLIM-INTERNALS::OBJECT))
;                                 (BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::EXPRESSION)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/presentation-defs.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT
;                                       (TYPE CLIM:EXPRESSION) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (LET ((*PRINT-READABLY*
;                                             CLIM-INTERNALS::ACCEPTABLY))
;                                        (PRIN1 CLIM-INTERNALS::OBJECT STREAM)))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::EXPRESSION)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::EXPRESSION)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a STANDARD-GENERIC-FUNCTION.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "clim-core" "presentation-defs">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/commands.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT
;                                       (TYPE CLIM-INTERNALS::EMPTY) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       &ALLOW-OTHER-KEYS)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::OBJECT STREAM)))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM-INTERNALS::EMPTY)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 &ALLOW-OTHER-KEYS)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::OBJECT STREAM))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM-INTERNALS::EMPTY)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/commands.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT
;                                       (TYPE CLIM:COMMAND-NAME))
;                                      (AND
;                                       (CLIM:COMMAND-ACCESSIBLE-IN-COMMAND-TABLE-P
;                                        CLIM-INTERNALS::OBJECT CLIM:COMMAND-TABLE)
;                                       (CLIM:COMMAND-ENABLED
;                                        CLIM-INTERNALS::OBJECT
;                                        CLIM:*APPLICATION-FRAME*)))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::COMMAND-NAME)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::COMMAND-NAME)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/commands.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT
;                                       (TYPE CLIM:COMMAND-NAME) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                      (LET ((CLIM-INTERNALS::COMMAND-LINE-NAME
;                                             (CLIM:COMMAND-LINE-NAME-FOR-COMMAND
;                                              CLIM-INTERNALS::OBJECT
;                                              CLIM:COMMAND-TABLE :ERRORP NIL)))
;                                        (IF CLIM-INTERNALS::COMMAND-LINE-NAME
;                                            (WRITE-STRING
;                                             CLIM-INTERNALS::COMMAND-LINE-NAME
;                                             STREAM)
;                                            (PRIN1 CLIM-INTERNALS::OBJECT
;                                                   STREAM))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::COMMAND-NAME)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                ((BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::COMMAND-NAME)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/commands.lisp
; in: DEFINE-PRESENTATION-METHOD ACCEPT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:ACCEPT
;                                      ((TYPE CLIM:COMMAND-NAME) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                      (FLET ((CLIM-INTERNALS::GENERATOR
;                                                 (STRING CLIM-INTERNALS::SUGGESTER)
;                                               (DECLARE #)
;                                               (LET #
;                                                 #
;                                                 #)))
;                                        (MULTIPLE-VALUE-BIND
;                                            (CLIM-INTERNALS::OBJECT
;                                             CLIM-INTERNALS::SUCCESS STRING)
;                                            (CLIM:COMPLETE-INPUT STREAM
;                                                                 #'(LAMBDA # #)
;                                                                 :PARTIAL-COMPLETERS
;                                                                 '(#\ ))
;                                          (IF CLIM-INTERNALS::SUCCESS
;                                              (VALUES CLIM-INTERNALS::OBJECT TYPE)
;                                              (CLIM:SIMPLE-PARSE-ERROR
;                                               "No command named ~S" STRING)))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%ACCEPT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::COMMAND-NAME)|)
;                                 TYPE STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                ((BLOCK CLIM:ACCEPT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::COMMAND-NAME)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/commands.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT (TYPE CLIM:COMMAND))
;                                      (AND (CONSP CLIM-INTERNALS::OBJECT)
;                                           (CLIM:PRESENTATION-TYPEP
;                                            (CAR CLIM-INTERNALS::OBJECT)
;                                            `(CLIM:COMMAND-NAME :COMMAND-TABLE
;                                              ,CLIM:COMMAND-TABLE))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::COMMAND)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::COMMAND)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/commands.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT (TYPE CLIM:COMMAND)
;                                       STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-INTERNALS::ACCEPTABLY
;                                       CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                        CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                      (FUNCALL CLIM:*COMMAND-UNPARSER*
;                                               CLIM:COMMAND-TABLE STREAM
;                                               CLIM-INTERNALS::OBJECT))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::COMMAND)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-INTERNALS::ACCEPTABLY
;                                 CLIM-INTERNALS::FOR-CONTEXT-TYPE)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::ACCEPTABLY
;                                   CLIM-INTERNALS::FOR-CONTEXT-TYPE))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::COMMAND)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/commands.lisp
; in: DEFINE-PRESENTATION-METHOD ACCEPT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:ACCEPT
;                                      ((TYPE CLIM:COMMAND) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                      (LET ((CLIM:COMMAND
;                                             (FUNCALL CLIM:*COMMAND-PARSER*
;                                                      CLIM:COMMAND-TABLE STREAM)))
;                                        (COND
;                                         ((NULL CLIM:COMMAND)
;                                          (CLIM:SIMPLE-PARSE-ERROR
;                                           "Empty command"))
;                                         ((CLIM:PARTIAL-COMMAND-P CLIM:COMMAND)
;                                          (FUNCALL CLIM:*PARTIAL-COMMAND-PARSER*
;                                                   CLIM:COMMAND-TABLE STREAM
;                                                   CLIM:COMMAND #))
;                                         (T (VALUES CLIM:COMMAND TYPE)))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%ACCEPT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::COMMAND)|)
;                                 TYPE STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                ((BLOCK CLIM:ACCEPT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::COMMAND)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/commands.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-INTERNALS::OBJECT
;                                       (TYPE CLIM-INTERNALS::NULL-COMMAND))
;                                      (AND (CONSP CLIM-INTERNALS::OBJECT)
;                                           (EQ (CAR CLIM-INTERNALS::OBJECT)
;                                               'CLIM-INTERNALS::COM-NULL-COMMAND)))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM-INTERNALS::NULL-COMMAND)|)
;                                 CLIM-INTERNALS::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM-INTERNALS::NULL-COMMAND)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/commands.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-INTERNALS::OBJECT
;                                       (TYPE CLIM-INTERNALS::NULL-COMMAND) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                      (DECLARE
;                                       (IGNORE CLIM-INTERNALS::OBJECT STREAM
;                                        CLIM:VIEW)))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM-INTERNALS::NULL-COMMAND)|)
;                                 CLIM-INTERNALS::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                ((DECLARE
;                                  (IGNORE CLIM-INTERNALS::OBJECT STREAM
;                                   CLIM:VIEW))
;                                 (BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM-INTERNALS::NULL-COMMAND)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/commands.lisp
; in: DEFINE-PRESENTATION-METHOD ACCEPT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:ACCEPT
;                                      ((TYPE CLIM:COMMAND-OR-FORM) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                      (LET ((CLIM-INTERNALS::COMMAND-PTYPE
;                                             `(CLIM:COMMAND :COMMAND-TABLE
;                                               ,CLIM:COMMAND-TABLE)))
;                                        (CLIM:WITH-INPUT-CONTEXT (`(OR
;                                                                    ,CLIM-INTERNALS::COMMAND-PTYPE
;                                                                    CLIM:FORM))
;                                            (CLIM-INTERNALS::OBJECT TYPE
;                                             CLIM:EVENT CLIM-INTERNALS::OPTIONS)
;                                            (LET (#)
;                                              (IF #
;                                                  #
;                                                  #))
;                                          (T
;                                           (FUNCALL # CLIM-INTERNALS::OBJECT TYPE
;                                                    CLIM:EVENT
;                                                    CLIM-INTERNALS::OPTIONS)))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%ACCEPT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM::COMMAND-OR-FORM)|)
;                                 TYPE STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                ((BLOCK CLIM:ACCEPT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM::COMMAND-OR-FORM)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "clim-core" "commands">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Core/clim-core/gadgets.lisp
; in: DEFMETHOD COMPOSE-SPACE (PUSH-BUTTON-PANE)
;     (DEFMETHOD CLIM:COMPOSE-SPACE
;                ((CLIM:GADGET CLIM:PUSH-BUTTON-PANE)
;                 &KEY CLIM-INTERNALS::WIDTH CLIM-INTERNALS::HEIGHT)
;       (CLIM:SPACE-REQUIREMENT+*
;        (CLIM:SPACE-REQUIREMENT+*
;         (CLIM-INTERNALS::COMPOSE-LABEL-SPACE CLIM:GADGET) :MIN-WIDTH
;         (* 2 (CLIM-INTERNALS::PANE-X-SPACING CLIM:GADGET)) :WIDTH
;         (* 2 (CLIM-INTERNALS::PANE-X-SPACING CLIM:GADGET)) :MAX-WIDTH CLIM:+FILL+
;         :MIN-HEIGHT (* 2 (CLIM-INTERNALS::PANE-Y-SPACING CLIM:GADGET)) :HEIGHT
;         (* 2 (CLIM-INTERNALS::PANE-Y-SPACING CLIM:GADGET)) ...)))
; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA (SB-PCL::FAST-METHOD CLIM:COMPOSE-SPACE
;                           (CLIM:PUSH-BUTTON-PANE))
;         (SB-PCL::.PV. SB-PCL::.NEXT-METHOD-CALL. CLIM:GADGET &KEY
;          CLIM-INTERNALS::WIDTH CLIM-INTERNALS::HEIGHT &ALLOW-OTHER-KEYS)
;       (DECLARE (IGNORABLE SB-PCL::.PV. SB-PCL::.NEXT-METHOD-CALL.)
;                (DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
;       (DECLARE (SB-PCL::%PARAMETER CLIM:GADGET))
;       (DECLARE (IGNORABLE CLIM:GADGET))
;       (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
;         (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ((CLIM:GADGET)
;                                                 SB-PCL::.NEXT-METHOD-CALL.
;                                                 (CLIM:GADGET) NIL
;                                                 :CALL-NEXT-METHOD-P NIL :SETQ-P
;                                                 NIL :PARAMETERS-SETQD NIL
;                                                 :METHOD-CELL (#:METHOD-CELL)
;                                                 ...)
;           (DECLARE (SB-PCL::%CLASS CLIM:GADGET CLIM:PUSH-BUTTON-PANE))
;           (LOCALLY
;            (DECLARE #)
;            (SYMBOL-MACROLET #
;              #
;              #)))))
; 
; caught STYLE-WARNING:
;   The variable WIDTH is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable HEIGHT is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "clim-core" "gadgets">
WARNING: redefining CLIM-INTERNALS::FINALIZE-QUERY-RECORD in DEFGENERIC
WARNING: redefining COMMON-LISP:READ in DEFUN
WARNING: redefining COMMON-LISP:READ-PRESERVING-WHITESPACE in DEFUN
WARNING: redefining EMACS-INSPECT (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining ESA-IO:BUFFER in DEFGENERIC
WARNING: redefining FLEXICHAIN:INSERT-SEQUENCE in DEFGENERIC
WARNING: redefining DREI-UNDO:UNDO-TREE in DEFGENERIC
WARNING: redefining DREI:POINT-OF in DEFGENERIC
WARNING: redefining DREI:MARK-OF in DEFGENERIC
WARNING: redefining DREI:ACTIVE in DEFGENERIC
WARNING: redefining DREI:DISPLAY-DREI-VIEW-CONTENTS in DEFGENERIC
WARNING: redefining DREI-MOTION:FORWARD-ONE-LIST in DEFGENERIC
WARNING: redefining DREI-MOTION:BACKWARD-ONE-LIST in DEFGENERIC

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Libraries/Drei/input-editor.lisp
; in:
;      DEFMETHOD PRESENTATION-REPLACE-INPUT (DREI-INPUT-EDITING-MIXIN T (EQL (QUOTE EXPRESSION)) T)
;     (VECTOR DREI:OBJECT)
; --> MAKE-ARRAY MAKE-ARRAY LOCALLY LIST 
; ==>
;   DREI:OBJECT
; 
; note: deleting unreachable code
WARNING: redefining DEFAULT-IMAGE NIL in DEFMETHOD
WARNING: redefining CLIM-INTERNALS::MAKE-ACTIVATION-GESTURES in DEFUN
WARNING: redefining CLIM-INTERNALS::MAKE-DELIMITER-GESTURES in DEFUN

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/clx.lisp
; in: DEFUN ENCODE-EVENT-MASK
;     (XLIB::X-TYPE-ERROR XLIB:EVENT-MASK 'XLIB:EVENT-MASK)
; ==>
;   XLIB:EVENT-MASK
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/clx.lisp
; in: DEFUN ENCODE-DEVICE-EVENT-MASK
;     (XLIB::X-TYPE-ERROR XLIB:DEVICE-EVENT-MASK 'XLIB:DEVICE-EVENT-MASK)
; ==>
;   XLIB:DEVICE-EVENT-MASK
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/clx.lisp
; in: DEFUN ENCODE-MODIFIER-MASK
;     (XLIB::X-TYPE-ERROR XLIB:MODIFIER-MASK 'XLIB:MODIFIER-MASK)
; ==>
;   XLIB:MODIFIER-MASK
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/clx.lisp
; in: DEFUN ENCODE-STATE-MASK
;     (XLIB::X-TYPE-ERROR XLIB::STATE-MASK
;      '(OR XLIB:MASK16 (XLIB::CLX-LIST XLIB:STATE-MASK-KEY)))
; ==>
;   XLIB::STATE-MASK
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/clx.lisp
; in: DEFUN ENCODE-POINTER-EVENT-MASK
;     (XLIB::X-TYPE-ERROR XLIB:POINTER-EVENT-MASK 'XLIB:POINTER-EVENT-MASK)
; ==>
;   XLIB:POINTER-EVENT-MASK
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/dependent.lisp
; in: DEFMACRO HOLDING-LOCK
;     (DEFMACRO XLIB::HOLDING-LOCK
;               (
;                (XLIB::LOCK
;                 XLIB:DISPLAY
;                 &OPTIONAL
;                 (XLIB::WHOSTATE "CLX wait")
;                 &KEY
;                 XLIB::TIMEOUT)
;                &BODY XLIB::BODY)
;       (DECLARE (IGNORE XLIB:DISPLAY XLIB::WHOSTATE))
;       (IF XLIB::TIMEOUT
;           `(IF ,XLIB::TIMEOUT
;                (HANDLER-CASE
;                 (WITH-TIMEOUT ,XLIB::TIMEOUT
;                   #)
;                 (TIMEOUT NIL NIL))
;                (SB-THREAD:WITH-RECURSIVE-LOCK (,XLIB::LOCK)
;                  ,@XLIB::BODY))
;           `(SB-THREAD:WITH-RECURSIVE-LOCK (,XLIB::LOCK)
;              ,@XLIB::BODY)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (LOCK DISPLAY &OPTIONAL (WHOSTATE "CLX wait") &KEY TIMEOUT)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/dependent.lisp
; in: DEFUN BUFFER-READ-DEFAULT
;     (SB-SYS:READ-N-BYTES (XLIB::DISPLAY-INPUT-STREAM XLIB:DISPLAY) VECTOR
;                          XLIB::START (- XLIB::END XLIB::START))
; --> BLOCK IF LET* SB-IMPL::EOF-OR-LOSE IF AND IF 
; ==>
;   (< SB-IMPL::READ-END SB-IMPL::END)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a (INTEGER -4611686018427387901 9223372036854775802), not a FIXNUM.

; --> BLOCK IF LET* 
; ==>
;   (STREAM-READ-SEQUENCE STREAM SB-IMPL::BUFFER SB-IMPL::START SB-IMPL::END)
; 
; note: doing signed word to integer coercion (cost 20) from SB-IMPL::END

; --> BLOCK IF LET* SB-IMPL::EOF-OR-LOSE IF AND IF 
; ==>
;   (< SB-IMPL::READ-END SB-IMPL::END)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-<

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/dependent.lisp
; in: DEFMACRO READ-IMAGE-LOAD-BYTE
;     (- 7 POSITION)
; ==>
;   POSITION
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/dependent.lisp
; in: DEFMACRO READ-IMAGE-ASSEMBLE-BYTES
;     (REVERSE XLIB::BYTES)
; ==>
;   XLIB::BYTES
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/dependent.lisp
; in: DEFMACRO WRITE-IMAGE-LOAD-BYTE
;     (- XLIB::INTEGER-SIZE 8 POSITION)
; --> - - 
; ==>
;   XLIB::INTEGER-SIZE
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/dependent.lisp
; in: DEFMACRO WRITE-IMAGE-ASSEMBLE-BYTES
;     (REVERSE XLIB::BYTES)
; ==>
;   XLIB::BYTES
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/dependent.lisp
; in: DEFUN FAST-READ-PIXARRAY
;     (XLIB::READ-PIXARRAY-INTERNAL XLIB::BBUF XLIB::BOFFSET XLIB:PIXARRAY XLIB::X
;      XLIB::Y XLIB::WIDTH XLIB::HEIGHT XLIB::PADDED-BYTES-PER-LINE
;      XLIB::BITS-PER-PIXEL FUNCTION XLIB::UNIT ...)
; ==>
;   XLIB::BBUF
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/dependent.lisp
; in: DEFUN FAST-WRITE-PIXARRAY-USING-BITBLT
;     (ARRAY-DIMENSION XLIB:PIXARRAY 1)
; 
; note: unable to optimize because: The array dimensions are unknown; must call ARRAY-DIMENSION at runtime.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/dependent.lisp
; in: DEFUN FAST-WRITE-PIXARRAY
;     (XLIB::WRITE-PIXARRAY-INTERNAL XLIB::BBUF XLIB::BOFFSET XLIB:PIXARRAY XLIB::X
;      XLIB::Y XLIB::WIDTH XLIB::HEIGHT XLIB::PADDED-BYTES-PER-LINE
;      XLIB::BITS-PER-PIXEL FUNCTION XLIB::+IMAGE-UNIT+ ...)
; ==>
;   XLIB::BBUF
; 
; note: deleting unreachable code
WARNING: Lisp compilation had style-warnings while compiling #<CLX-SOURCE-FILE "clx" "dependent">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/macros.lisp
; in: DEFMACRO DEFINE-ACCESSOR
;     (LET ((XLIB::PREDICATING-PUT (THIRD XLIB::GET-PUT-MACROS)))
;       (WHEN XLIB::PREDICATING-PUT
;         `((SETF # T)
;           (DEFMACRO ,(XLIB::PUTIFY XLIB::NAME T) ,(CAR XLIB::PREDICATING-PUT)
;             ,@(CDR XLIB::PREDICATING-PUT)))))
; 
; note: deleting unreachable code

; in: DEFMACRO DEFINE-ACCESSOR => DEFMACRO #S(SB-IMPL::COMMA :EXPR (PUTIFY NAME T) :KIND 0)
;     (XLIB::PUTIFY XLIB::NAME T)
; ==>
;   XLIB::NAME
; 
; note: deleting unreachable code

; in: DEFMACRO DEFINE-ACCESSOR
;     (WHEN XLIB::PREDICATING-PUT
;       `((SETF (GET ',XLIB::NAME 'XLIB::PREDICATING-PUT) T)
;         (DEFMACRO ,(XLIB::PUTIFY XLIB::NAME T) ,(CAR XLIB::PREDICATING-PUT)
;           ,@(CDR XLIB::PREDICATING-PUT))))
; --> IF 
; ==>
;   XLIB::PREDICATING-PUT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/macros.lisp
; in: DEFUN MASK-GET
;     (DEFUN XLIB::MASK-GET (XLIB::INDEX XLIB::TYPE-VALUES XLIB::BODY-FUNCTION)
;       (DECLARE (TYPE FUNCTION XLIB::BODY-FUNCTION)
;                (DYNAMIC-EXTENT XLIB::BODY-FUNCTION))
;       (LET* ((BIT 0) (XLIB::RESULT (MAPCAR #'# #)))
;         `(,@(WHEN (ATOM #) (LIST #))
;           (PROGN (SETQ #) (SETQ #) ,(CAR XLIB::RESULT)) ,@(CDR XLIB::RESULT))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G59
; 
; note: could not stack allocate BODY-FUNCTION in: (DEFUN MASK-GET (INDEX TYPE-VALUES BODY-FUNCTION) (DECLARE (TYPE FUNCTION BODY-FUNCTION) (DYNAMIC-EXTENT BODY-FUNCTION)) (LET* ((BIT 0) (RESULT (MAPCAR (FUNCTION (LAMBDA (FORM) (IF (ATOM FORM) FORM (PROG1 (SB-INT:QUASIQUOTE (WHEN (LOGBITP #S(SB-IMPL::COMMA :EXPR BIT :KIND 0) %MASK) #S(SB-IMPL::COMMA :EXPR FORM :KIND 0))) (INCF BIT))))) (GET-PUT-ITEMS (+ INDEX 4) TYPE-VALUES NIL (FUNCTION (LAMBDA (TYPE INDEX ITEM ARGS) (DECLARE (IGNORE INDEX)) (FUNCALL BODY-FUNCTION TYPE (QUOTE (* (INCF %INDEX) 4)) ITEM ARGS))))))) (SB-INT:QUASIQUOTE (#S(SB-IMPL::COMMA :EXPR (WHEN (ATOM (CAR RESULT)) (LIST (POP RESULT))) :KIND 2) (PROGN (SETQ %MASK (READ-CARD32 #S(SB-IMPL::COMMA :EXPR INDEX :KIND 0))) (SETQ %INDEX #S(SB-IMPL::COMMA :EXPR (CEILING INDEX 4) :KIND 0)) #S(SB-IMPL::COMMA :EXPR (CAR RESULT) :KIND 0)) #S(SB-IMPL::COMMA :EXPR (CDR RESULT) :KIND 2)))))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/macros.lisp
; in: DEFUN MASK-PUT
;     (DEFUN XLIB::MASK-PUT (XLIB::INDEX XLIB::TYPE-VALUES XLIB::BODY-FUNCTION)
;       (DECLARE (TYPE FUNCTION XLIB::BODY-FUNCTION)
;                (DYNAMIC-EXTENT XLIB::BODY-FUNCTION))
;       `((LET ((XLIB::%MASK 0) (XLIB::%INDEX ,XLIB::INDEX))
;           ,@(LET (#)
;               (XLIB::GET-PUT-ITEMS XLIB::INDEX XLIB::TYPE-VALUES T #'#))
;           (XLIB::WRITE-CARD32 ,XLIB::INDEX XLIB::%MASK)
;           (XLIB::WRITE-CARD16 2 (XLIB::INDEX-CEILING # 4))
;           (INCF (XLIB::BUFFER-BOFFSET XLIB::%BUFFER) XLIB::%INDEX))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G64
; 
; note: could not stack allocate BODY-FUNCTION in: (DEFUN MASK-PUT (INDEX TYPE-VALUES BODY-FUNCTION) (DECLARE (TYPE FUNCTION BODY-FUNCTION) (DYNAMIC-EXTENT BODY-FUNCTION)) (SB-INT:QUASIQUOTE ((LET ((%MASK 0) (%INDEX #S(SB-IMPL::COMMA :EXPR INDEX :KIND 0))) #S(SB-IMPL::COMMA :EXPR (LET ((BIT 1)) (GET-PUT-ITEMS INDEX TYPE-VALUES T (FUNCTION (LAMBDA (TYPE INDEX ITEM ARGS) (DECLARE (IGNORE INDEX)) (IF (OR (SYMBOLP ITEM) (CONSTANTP ITEM)) (SB-INT:QUASIQUOTE ((UNLESS (NULL #S(SB-IMPL::COMMA :EXPR ITEM :KIND 0)) (SETQ %MASK (LOGIOR %MASK #S(SB-IMPL::COMMA :EXPR (SHIFTF BIT (ASH BIT 1)) :KIND 0))) #S(SB-IMPL::COMMA :EXPR (FUNCALL BODY-FUNCTION TYPE (SB-INT:QUASIQUOTE (INDEX-INCF %INDEX 4)) ITEM ARGS) :KIND 2)))) (SB-INT:QUASIQUOTE ((LET ((.ITEM. #S(SB-IMPL::COMMA :EXPR ITEM :KIND 0))) (UNLESS (NULL .ITEM.) (SETQ %MASK (LOGIOR %MASK #S(SB-IMPL::COMMA :EXPR (SHIFTF BIT (ASH BIT 1)) :KIND 0))) #S(SB-IMPL::COMMA :EXPR (FUNCALL BODY-FUNCTION TYPE (SB-INT:QUASIQUOTE (INDEX-INCF %INDEX 4)) (QUOTE .ITEM.) ARGS) :KIND 2)))))))))) :KIND 2) (WRITE-CARD32 #S(SB-IMPL::COMMA :EXPR INDEX :KIND 0) %MASK) (WRITE-CARD16 2 (INDEX-CEILING (INDEX-INCF %INDEX 4) 4)) (INCF (BUFFER-BOFFSET %BUFFER) %INDEX)))))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/macros.lisp
; in: DEFUN GET-PUT-ITEMS
;     (DEFUN XLIB::GET-PUT-ITEMS
;            (XLIB::INDEX XLIB::TYPE-ARGS XLIB::PUTP &OPTIONAL XLIB::BODY-FUNCTION)
;       (DECLARE (TYPE (OR NULL FUNCTION) XLIB::BODY-FUNCTION)
;                (DYNAMIC-EXTENT XLIB::BODY-FUNCTION))
;       (UNLESS XLIB::BODY-FUNCTION (SETQ XLIB::BODY-FUNCTION #'(LAMBDA # `#)))
;       (DO* ((XLIB::ITEMS XLIB::TYPE-ARGS (CDR XLIB::ITEMS))
;             (TYPE (CAAR XLIB::ITEMS) (CAAR XLIB::ITEMS))
;             (XLIB::ARGS NIL NIL)
;             (XLIB::RESULT NIL)
;             (XLIB::SIZES NIL))
;            ((ENDP XLIB::ITEMS) (VALUES XLIB::RESULT XLIB::INDEX XLIB::SIZES))
;         (WHEN (CONSP TYPE)
;           (SETQ XLIB::ARGS #
;                 TYPE #))
;         (COND ((MEMBER TYPE '#)) ((EQ TYPE 'XLIB::MASK) (SETQ #))
;               (T (DO* # # # # #)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION COND 
; --> IF THE SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G111
; 
; note: could not stack allocate BODY-FUNCTION in: (DEFUN GET-PUT-ITEMS (INDEX TYPE-ARGS PUTP &OPTIONAL BODY-FUNCTION) (DECLARE (TYPE (OR NULL FUNCTION) BODY-FUNCTION) (DYNAMIC-EXTENT BODY-FUNCTION)) (UNLESS BODY-FUNCTION (SETQ BODY-FUNCTION (FUNCTION (LAMBDA (TYPE INDEX ITEM ARGS) (SB-INT:QUASIQUOTE ((CHECK-PUT #S(SB-IMPL::COMMA :EXPR INDEX :KIND 0) #S(SB-IMPL::COMMA :EXPR ITEM :KIND 0) #S(SB-IMPL::COMMA :EXPR TYPE :KIND 0) #S(SB-IMPL::COMMA :EXPR ARGS :KIND 2)))))))) (DO* ((ITEMS TYPE-ARGS (CDR ITEMS)) (TYPE (CAAR ITEMS) (CAAR ITEMS)) (ARGS NIL NIL) (RESULT NIL) (SIZES NIL)) ((ENDP ITEMS) (VALUES RESULT INDEX SIZES)) (WHEN (CONSP TYPE) (SETQ ARGS (CDR TYPE) TYPE (CAR TYPE))) (COND ((MEMBER TYPE (QUOTE (RETURN BUFFER)))) ((EQ TYPE (QUOTE MASK)) (SETQ RESULT (APPEND RESULT (IF PUTP (MASK-PUT INDEX (CDAR ITEMS) BODY-FUNCTION) (MASK-GET INDEX (CDAR ITEMS) BODY-FUNCTION))) INDEX NIL)) (T (DO* ((ITEM (CDAR ITEMS) (CDR ITEM)) (INCREMENT (INDEX-INCREMENT TYPE))) ((ENDP ITEM)) (WHEN (CONSTANTP INDEX) (CASE INCREMENT (2 (SETQ INDEX (WROUND INDEX))) (4 (SETQ INDEX (LROUND INDEX))))) (SETQ RESULT (APPEND RESULT (FUNCALL BODY-FUNCTION TYPE INDEX (CAR ITEM) ARGS))) (WHEN (CONSTANTP INDEX) (IF (NULL INCREMENT) (SETQ INDEX NIL) (PROGN (INCF INDEX INCREMENT) (WHEN (AND INCREMENT (ZEROP INCREMENT)) (SETQ INCREMENT 1)) (PUSHNEW (* INCREMENT 8) SIZES)))))))))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WITH-BUFFER-FUNCTION
;     (XLIB::WITH-BUFFER (XLIB::BUFFER :TIMEOUT XLIB::TIMEOUT :INLINE T)
;       (FUNCALL FUNCTION))
; --> MACROLET LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET 
; --> #:FORM-FUN-4 BLOCK PROGN WITH-TIMEOUT SB-INT:DX-FLET FLET LET IF 
; ==>
;   (> SB-IMPL::EXPIRES 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (DEFUN XLIB::WITH-BUFFER-FUNCTION (XLIB::BUFFER XLIB::TIMEOUT FUNCTION)
;       (DECLARE (TYPE XLIB:DISPLAY XLIB::BUFFER)
;                (TYPE (OR NULL NUMBER) XLIB::TIMEOUT)
;                (TYPE FUNCTION FUNCTION)
;                (DYNAMIC-EXTENT FUNCTION)
;                (IGNORABLE XLIB::TIMEOUT))
;       (XLIB::WITH-BUFFER (XLIB::BUFFER :TIMEOUT XLIB::TIMEOUT :INLINE T)
;         (FUNCALL FUNCTION)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G24
; 
; note: could not stack allocate FUNCTION in: (DEFUN WITH-BUFFER-FUNCTION (BUFFER TIMEOUT FUNCTION) (DECLARE (TYPE DISPLAY BUFFER) (TYPE (OR NULL NUMBER) TIMEOUT) (TYPE FUNCTION FUNCTION) (DYNAMIC-EXTENT FUNCTION) (IGNORABLE TIMEOUT)) (WITH-BUFFER (BUFFER :TIMEOUT TIMEOUT :INLINE T) (FUNCALL FUNCTION)))

;     (XLIB::WITH-BUFFER (XLIB::BUFFER :TIMEOUT XLIB::TIMEOUT :INLINE T)
;       (FUNCALL FUNCTION))
; --> MACROLET LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET 
; --> #:FORM-FUN-4 BLOCK PROGN WITH-TIMEOUT SB-INT:DX-FLET FLET LET IF 
; ==>
;   (> SB-IMPL::EXPIRES 0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WITH-BUFFER-REQUEST-FUNCTION
;     (DEFUN XLIB::WITH-BUFFER-REQUEST-FUNCTION
;            (XLIB:DISPLAY XLIB::GC-FORCE XLIB::REQUEST-FUNCTION)
;       (DECLARE (TYPE XLIB:DISPLAY XLIB:DISPLAY)
;                (TYPE (OR NULL XLIB:GCONTEXT) XLIB::GC-FORCE))
;       (DECLARE (TYPE FUNCTION XLIB::REQUEST-FUNCTION)
;                (DYNAMIC-EXTENT XLIB::REQUEST-FUNCTION))
;       (XLIB::WITH-BUFFER (XLIB:DISPLAY :INLINE T)
;         (MULTIPLE-VALUE-PROG1
;             (PROGN
;              (WHEN XLIB::GC-FORCE #)
;              (XLIB::WITHOUT-ABORTS
;                #))
;           (XLIB:DISPLAY-INVOKE-AFTER-FUNCTION XLIB:DISPLAY))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G7
; 
; note: could not stack allocate REQUEST-FUNCTION in: (DEFUN WITH-BUFFER-REQUEST-FUNCTION (DISPLAY GC-FORCE REQUEST-FUNCTION) (DECLARE (TYPE DISPLAY DISPLAY) (TYPE (OR NULL GCONTEXT) GC-FORCE)) (DECLARE (TYPE FUNCTION REQUEST-FUNCTION) (DYNAMIC-EXTENT REQUEST-FUNCTION)) (WITH-BUFFER (DISPLAY :INLINE T) (MULTIPLE-VALUE-PROG1 (PROGN (WHEN GC-FORCE (FORCE-GCONTEXT-CHANGES-INTERNAL GC-FORCE)) (WITHOUT-ABORTS (FUNCALL REQUEST-FUNCTION DISPLAY))) (DISPLAY-INVOKE-AFTER-FUNCTION DISPLAY))))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WITH-BUFFER-REQUEST-FUNCTION-NOLOCK
;     (DEFUN XLIB::WITH-BUFFER-REQUEST-FUNCTION-NOLOCK
;            (XLIB:DISPLAY XLIB::GC-FORCE XLIB::REQUEST-FUNCTION)
;       (DECLARE (TYPE XLIB:DISPLAY XLIB:DISPLAY)
;                (TYPE (OR NULL XLIB:GCONTEXT) XLIB::GC-FORCE))
;       (DECLARE (TYPE FUNCTION XLIB::REQUEST-FUNCTION)
;                (DYNAMIC-EXTENT XLIB::REQUEST-FUNCTION))
;       (MULTIPLE-VALUE-PROG1
;           (PROGN
;            (WHEN XLIB::GC-FORCE
;              (XLIB::FORCE-GCONTEXT-CHANGES-INTERNAL XLIB::GC-FORCE))
;            (XLIB::WITHOUT-ABORTS
;              (FUNCALL XLIB::REQUEST-FUNCTION XLIB:DISPLAY)))
;         (XLIB:DISPLAY-INVOKE-AFTER-FUNCTION XLIB:DISPLAY)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G6
; 
; note: could not stack allocate REQUEST-FUNCTION in: (DEFUN WITH-BUFFER-REQUEST-FUNCTION-NOLOCK (DISPLAY GC-FORCE REQUEST-FUNCTION) (DECLARE (TYPE DISPLAY DISPLAY) (TYPE (OR NULL GCONTEXT) GC-FORCE)) (DECLARE (TYPE FUNCTION REQUEST-FUNCTION) (DYNAMIC-EXTENT REQUEST-FUNCTION)) (MULTIPLE-VALUE-PROG1 (PROGN (WHEN GC-FORCE (FORCE-GCONTEXT-CHANGES-INTERNAL GC-FORCE)) (WITHOUT-ABORTS (FUNCALL REQUEST-FUNCTION DISPLAY))) (DISPLAY-INVOKE-AFTER-FUNCTION DISPLAY)))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WITH-BUFFER-REQUEST-AND-REPLY-FUNCTION
;     (DEFUN XLIB::WITH-BUFFER-REQUEST-AND-REPLY-FUNCTION
;            (XLIB:DISPLAY XLIB::MULTIPLE-REPLY XLIB::REQUEST-FUNCTION
;             XLIB::REPLY-FUNCTION)
;       (DECLARE (TYPE XLIB:DISPLAY XLIB:DISPLAY)
;                (TYPE XLIB:GENERALIZED-BOOLEAN XLIB::MULTIPLE-REPLY))
;       (DECLARE (TYPE FUNCTION XLIB::REQUEST-FUNCTION XLIB::REPLY-FUNCTION)
;                (DYNAMIC-EXTENT XLIB::REQUEST-FUNCTION XLIB::REPLY-FUNCTION))
;       (LET ((XLIB::PENDING-COMMAND NIL) (XLIB::REPLY-BUFFER NIL))
;         (DECLARE (TYPE (OR NULL XLIB::PENDING-COMMAND) XLIB::PENDING-COMMAND)
;                  (TYPE (OR NULL XLIB::REPLY-BUFFER) XLIB::REPLY-BUFFER))
;         (UNWIND-PROTECT
;             (PROGN
;              (XLIB::WITH-BUFFER #
;                #
;                #
;                #
;                #)
;              (COND # #))
;           (WHEN XLIB::REPLY-BUFFER
;             (XLIB::DEALLOCATE-REPLY-BUFFER XLIB::REPLY-BUFFER))
;           (WHEN XLIB::PENDING-COMMAND
;             (XLIB::STOP-PENDING-COMMAND XLIB:DISPLAY XLIB::PENDING-COMMAND)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G34
; 
; note: could not stack allocate REQUEST-FUNCTION in: (DEFUN WITH-BUFFER-REQUEST-AND-REPLY-FUNCTION (DISPLAY MULTIPLE-REPLY REQUEST-FUNCTION REPLY-FUNCTION) (DECLARE (TYPE DISPLAY DISPLAY) (TYPE GENERALIZED-BOOLEAN MULTIPLE-REPLY)) (DECLARE (TYPE FUNCTION REQUEST-FUNCTION REPLY-FUNCTION) (DYNAMIC-EXTENT REQUEST-FUNCTION REPLY-FUNCTION)) (LET ((PENDING-COMMAND NIL) (REPLY-BUFFER NIL)) (DECLARE (TYPE (OR NULL PENDING-COMMAND) PENDING-COMMAND) (TYPE (OR NULL REPLY-BUFFER) REPLY-BUFFER)) (UNWIND-PROTECT (PROGN (WITH-BUFFER (DISPLAY :INLINE T) (SETQ PENDING-COMMAND (START-PENDING-COMMAND DISPLAY)) (WITHOUT-ABORTS (FUNCALL REQUEST-FUNCTION DISPLAY)) (BUFFER-FORCE-OUTPUT DISPLAY) (DISPLAY-INVOKE-AFTER-FUNCTION DISPLAY)) (COND (MULTIPLE-REPLY (LOOP (SETQ REPLY-BUFFER (READ-REPLY DISPLAY PENDING-COMMAND)) (WHEN (FUNCALL REPLY-FUNCTION DISPLAY REPLY-BUFFER) (RETURN NIL)) (DEALLOCATE-REPLY-BUFFER (SHIFTF REPLY-BUFFER NIL)))) (T (SETQ REPLY-BUFFER (READ-REPLY DISPLAY PENDING-COMMAND)) (FUNCALL REPLY-FUNCTION DISPLAY REPLY-BUFFER)))) (WHEN REPLY-BUFFER (DEALLOCATE-REPLY-BUFFER REPLY-BUFFER)) (WHEN PENDING-COMMAND (STOP-PENDING-COMMAND DISPLAY PENDING-COMMAND)))))

; ==>
;   #:G40
; 
; note: could not stack allocate REPLY-FUNCTION in: (DEFUN WITH-BUFFER-REQUEST-AND-REPLY-FUNCTION (DISPLAY MULTIPLE-REPLY REQUEST-FUNCTION REPLY-FUNCTION) (DECLARE (TYPE DISPLAY DISPLAY) (TYPE GENERALIZED-BOOLEAN MULTIPLE-REPLY)) (DECLARE (TYPE FUNCTION REQUEST-FUNCTION REPLY-FUNCTION) (DYNAMIC-EXTENT REQUEST-FUNCTION REPLY-FUNCTION)) (LET ((PENDING-COMMAND NIL) (REPLY-BUFFER NIL)) (DECLARE (TYPE (OR NULL PENDING-COMMAND) PENDING-COMMAND) (TYPE (OR NULL REPLY-BUFFER) REPLY-BUFFER)) (UNWIND-PROTECT (PROGN (WITH-BUFFER (DISPLAY :INLINE T) (SETQ PENDING-COMMAND (START-PENDING-COMMAND DISPLAY)) (WITHOUT-ABORTS (FUNCALL REQUEST-FUNCTION DISPLAY)) (BUFFER-FORCE-OUTPUT DISPLAY) (DISPLAY-INVOKE-AFTER-FUNCTION DISPLAY)) (COND (MULTIPLE-REPLY (LOOP (SETQ REPLY-BUFFER (READ-REPLY DISPLAY PENDING-COMMAND)) (WHEN (FUNCALL REPLY-FUNCTION DISPLAY REPLY-BUFFER) (RETURN NIL)) (DEALLOCATE-REPLY-BUFFER (SHIFTF REPLY-BUFFER NIL)))) (T (SETQ REPLY-BUFFER (READ-REPLY DISPLAY PENDING-COMMAND)) (FUNCALL REPLY-FUNCTION DISPLAY REPLY-BUFFER)))) (WHEN REPLY-BUFFER (DEALLOCATE-REPLY-BUFFER REPLY-BUFFER)) (WHEN PENDING-COMMAND (STOP-PENDING-COMMAND DISPLAY PENDING-COMMAND)))))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFINE-TRANSFORMED-SEQUENCE-READER READ-SEQUENCE-CHAR
;     (XLIB::DEFINE-TRANSFORMED-SEQUENCE-READER XLIB::READ-SEQUENCE-CHAR CHARACTER
;                                               XLIB:CARD8->CHAR
;                                               XLIB::READ-SEQUENCE-CARD8)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> COND IF IF IF IF THE SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 
; --> LET 
; ==>
;   #:G21
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-TRANSFORMED-SEQUENCE-READER READ-SEQUENCE-CHAR CHARACTER CARD8->CHAR READ-SEQUENCE-CARD8)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in:
;      DEFINE-LIST-READERS (READ-LIST-CARD8 READ-LIST-CARD8-WITH-TRANSFORM)
;     (XLIB::DEFINE-LIST-READERS
;      (XLIB::READ-LIST-CARD8 XLIB::READ-LIST-CARD8-WITH-TRANSFORM) XLIB:CARD8 8 1
;      XLIB::READ-CARD8)
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G44
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-LIST-READERS (READ-LIST-CARD8 READ-LIST-CARD8-WITH-TRANSFORM) CARD8 8 1 READ-CARD8)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN READ-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM
;     (DEFUN XLIB::READ-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM
;            (XLIB::REPLY-BUFFER XLIB::NITEMS XLIB::DATA XLIB::TRANSFORM
;             XLIB::START XLIB::INDEX)
;       (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER)
;                (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX)
;                (TYPE (SIMPLE-ARRAY XLIB:CARD8 (*)) XLIB::DATA))
;       (DECLARE (TYPE (FUNCTION (XLIB:CARD8) XLIB:CARD8) XLIB::TRANSFORM)
;                (DYNAMIC-EXTENT XLIB::TRANSFORM))
;       (XLIB::WITH-VECTOR (XLIB::DATA (SIMPLE-ARRAY XLIB:CARD8 (*)))
;         (XLIB::WITH-BUFFER-INPUT (XLIB::REPLY-BUFFER :SIZES (8) :INDEX
;                                   XLIB::INDEX)
;           (DO* (#
;                 #
;                 #)
;                (#)
;             (DECLARE #)
;             (SETF #)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G20
; 
; note: could not stack allocate TRANSFORM in: (DEFUN READ-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM (REPLY-BUFFER NITEMS DATA TRANSFORM START INDEX) (DECLARE (TYPE REPLY-BUFFER REPLY-BUFFER) (TYPE ARRAY-INDEX NITEMS START INDEX) (TYPE (SIMPLE-ARRAY CARD8 (*)) DATA)) (DECLARE (TYPE (FUNCTION (CARD8) CARD8) TRANSFORM) (DYNAMIC-EXTENT TRANSFORM)) (WITH-VECTOR (DATA (SIMPLE-ARRAY CARD8 (*))) (WITH-BUFFER-INPUT (REPLY-BUFFER :SIZES (8) :INDEX INDEX) (DO* ((J START (INDEX+ J 1)) (END (INDEX+ START NITEMS)) (INDEX 0 (INDEX+ INDEX 1))) ((INDEX>= J END)) (DECLARE (TYPE ARRAY-INDEX J END INDEX)) (SETF (AREF DATA J) (THE CARD8 (FUNCALL TRANSFORM (READ-CARD8 INDEX))))))))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN READ-VECTOR-CARD8
;     (SETF (AREF XLIB::DATA XLIB::J) (XLIB::READ-CARD8 XLIB::INDEX))
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN READ-VECTOR-CARD8-WITH-TRANSFORM
;     (SETF (AREF XLIB::DATA XLIB::J)
;             (FUNCALL XLIB::TRANSFORM (XLIB::READ-CARD8 XLIB::INDEX)))
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (DEFUN XLIB::READ-VECTOR-CARD8-WITH-TRANSFORM
;            (XLIB::REPLY-BUFFER XLIB::NITEMS XLIB::DATA XLIB::TRANSFORM
;             XLIB::START XLIB::INDEX)
;       (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER)
;                (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX)
;                (TYPE VECTOR XLIB::DATA)
;                (OPTIMIZE))
;       (DECLARE (TYPE (FUNCTION (XLIB:CARD8) T) XLIB::TRANSFORM)
;                (DYNAMIC-EXTENT XLIB::TRANSFORM))
;       (XLIB::WITH-VECTOR (XLIB::DATA VECTOR)
;         (XLIB::WITH-BUFFER-INPUT (XLIB::REPLY-BUFFER :SIZES (8) :INDEX
;                                   XLIB::INDEX)
;           (DO* (#
;                 #
;                 #)
;                (#)
;             (DECLARE #)
;             (SETF #)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G17
; 
; note: could not stack allocate TRANSFORM in: (DEFUN READ-VECTOR-CARD8-WITH-TRANSFORM (REPLY-BUFFER NITEMS DATA TRANSFORM START INDEX) (DECLARE (TYPE REPLY-BUFFER REPLY-BUFFER) (TYPE ARRAY-INDEX NITEMS START INDEX) (TYPE VECTOR DATA) (OPTIMIZE)) (DECLARE (TYPE (FUNCTION (CARD8) T) TRANSFORM) (DYNAMIC-EXTENT TRANSFORM)) (WITH-VECTOR (DATA VECTOR) (WITH-BUFFER-INPUT (REPLY-BUFFER :SIZES (8) :INDEX INDEX) (DO* ((J START (INDEX+ J 1)) (END (INDEX+ START NITEMS)) (INDEX 0 (INDEX+ INDEX 1))) ((INDEX>= J END)) (DECLARE (TYPE ARRAY-INDEX J END INDEX)) (SETF (AREF DATA J) (FUNCALL TRANSFORM (READ-CARD8 INDEX)))))))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFINE-SEQUENCE-READER READ-SEQUENCE-CARD8
;     (XLIB::DEFINE-SEQUENCE-READER XLIB::READ-SEQUENCE-CARD8 XLIB:CARD8
;                                   (XLIB::READ-LIST-CARD8
;                                    XLIB::READ-LIST-CARD8-WITH-TRANSFORM)
;                                   (XLIB::READ-SIMPLE-ARRAY-CARD8
;                                    XLIB::READ-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM)
;                                   (XLIB::READ-VECTOR-CARD8
;                                    XLIB::READ-VECTOR-CARD8-WITH-TRANSFORM))
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> COND IF IF IF IF THE SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 
; --> LET 
; ==>
;   #:G18
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-SEQUENCE-READER READ-SEQUENCE-CARD8 CARD8 (READ-LIST-CARD8 READ-LIST-CARD8-WITH-TRANSFORM) (READ-SIMPLE-ARRAY-CARD8 READ-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM) (READ-VECTOR-CARD8 READ-VECTOR-CARD8-WITH-TRANSFORM))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFINE-TRANSFORMED-SEQUENCE-READER READ-SEQUENCE-INT8
;     (XLIB::DEFINE-TRANSFORMED-SEQUENCE-READER XLIB::READ-SEQUENCE-INT8 XLIB:INT8
;                                               XLIB::CARD8->INT8
;                                               XLIB::READ-SEQUENCE-CARD8)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> COND IF IF IF IF THE SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 
; --> LET 
; ==>
;   #:G21
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-TRANSFORMED-SEQUENCE-READER READ-SEQUENCE-INT8 INT8 CARD8->INT8 READ-SEQUENCE-CARD8)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in:
;      DEFINE-LIST-READERS (READ-LIST-CARD16 READ-LIST-CARD16-WITH-TRANSFORM)
;     (XLIB::DEFINE-LIST-READERS
;      (XLIB::READ-LIST-CARD16 XLIB::READ-LIST-CARD16-WITH-TRANSFORM) XLIB:CARD16
;      16 2 XLIB::READ-CARD16)
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G44
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-LIST-READERS (READ-LIST-CARD16 READ-LIST-CARD16-WITH-TRANSFORM) CARD16 16 2 READ-CARD16)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN READ-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM
;     (DEFUN XLIB::READ-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM
;            (XLIB::REPLY-BUFFER XLIB::NITEMS XLIB::DATA XLIB::TRANSFORM
;             XLIB::START XLIB::INDEX)
;       (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER)
;                (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX)
;                (TYPE (SIMPLE-ARRAY XLIB:CARD16 (*)) XLIB::DATA))
;       (DECLARE (TYPE (FUNCTION (XLIB:CARD16) XLIB:CARD16) XLIB::TRANSFORM)
;                (DYNAMIC-EXTENT XLIB::TRANSFORM))
;       (XLIB::WITH-VECTOR (XLIB::DATA (SIMPLE-ARRAY XLIB:CARD16 (*)))
;         (XLIB::WITH-BUFFER-INPUT (XLIB::REPLY-BUFFER :SIZES (16) :INDEX
;                                   XLIB::INDEX)
;           (DO* (#
;                 #
;                 #)
;                (#)
;             (DECLARE #)
;             (SETF #)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G20
; 
; note: could not stack allocate TRANSFORM in: (DEFUN READ-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM (REPLY-BUFFER NITEMS DATA TRANSFORM START INDEX) (DECLARE (TYPE REPLY-BUFFER REPLY-BUFFER) (TYPE ARRAY-INDEX NITEMS START INDEX) (TYPE (SIMPLE-ARRAY CARD16 (*)) DATA)) (DECLARE (TYPE (FUNCTION (CARD16) CARD16) TRANSFORM) (DYNAMIC-EXTENT TRANSFORM)) (WITH-VECTOR (DATA (SIMPLE-ARRAY CARD16 (*))) (WITH-BUFFER-INPUT (REPLY-BUFFER :SIZES (16) :INDEX INDEX) (DO* ((J START (INDEX+ J 1)) (END (INDEX+ START NITEMS)) (INDEX 0 (INDEX+ INDEX 2))) ((INDEX>= J END)) (DECLARE (TYPE ARRAY-INDEX J END INDEX)) (SETF (AREF DATA J) (THE CARD16 (FUNCALL TRANSFORM (READ-CARD16 INDEX))))))))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN READ-VECTOR-CARD16
;     (SETF (AREF XLIB::DATA XLIB::J) (XLIB::READ-CARD16 XLIB::INDEX))
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN READ-VECTOR-CARD16-WITH-TRANSFORM
;     (SETF (AREF XLIB::DATA XLIB::J)
;             (FUNCALL XLIB::TRANSFORM (XLIB::READ-CARD16 XLIB::INDEX)))
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (DEFUN XLIB::READ-VECTOR-CARD16-WITH-TRANSFORM
;            (XLIB::REPLY-BUFFER XLIB::NITEMS XLIB::DATA XLIB::TRANSFORM
;             XLIB::START XLIB::INDEX)
;       (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER)
;                (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX)
;                (TYPE VECTOR XLIB::DATA)
;                (OPTIMIZE))
;       (DECLARE (TYPE (FUNCTION (XLIB:CARD16) T) XLIB::TRANSFORM)
;                (DYNAMIC-EXTENT XLIB::TRANSFORM))
;       (XLIB::WITH-VECTOR (XLIB::DATA VECTOR)
;         (XLIB::WITH-BUFFER-INPUT (XLIB::REPLY-BUFFER :SIZES (16) :INDEX
;                                   XLIB::INDEX)
;           (DO* (#
;                 #
;                 #)
;                (#)
;             (DECLARE #)
;             (SETF #)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G17
; 
; note: could not stack allocate TRANSFORM in: (DEFUN READ-VECTOR-CARD16-WITH-TRANSFORM (REPLY-BUFFER NITEMS DATA TRANSFORM START INDEX) (DECLARE (TYPE REPLY-BUFFER REPLY-BUFFER) (TYPE ARRAY-INDEX NITEMS START INDEX) (TYPE VECTOR DATA) (OPTIMIZE)) (DECLARE (TYPE (FUNCTION (CARD16) T) TRANSFORM) (DYNAMIC-EXTENT TRANSFORM)) (WITH-VECTOR (DATA VECTOR) (WITH-BUFFER-INPUT (REPLY-BUFFER :SIZES (16) :INDEX INDEX) (DO* ((J START (INDEX+ J 1)) (END (INDEX+ START NITEMS)) (INDEX 0 (INDEX+ INDEX 2))) ((INDEX>= J END)) (DECLARE (TYPE ARRAY-INDEX J END INDEX)) (SETF (AREF DATA J) (FUNCALL TRANSFORM (READ-CARD16 INDEX)))))))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFINE-SEQUENCE-READER READ-SEQUENCE-CARD16
;     (XLIB::DEFINE-SEQUENCE-READER XLIB::READ-SEQUENCE-CARD16 XLIB:CARD16
;                                   (XLIB::READ-LIST-CARD16
;                                    XLIB::READ-LIST-CARD16-WITH-TRANSFORM)
;                                   (XLIB::READ-SIMPLE-ARRAY-CARD16
;                                    XLIB::READ-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM)
;                                   (XLIB::READ-VECTOR-CARD16
;                                    XLIB::READ-VECTOR-CARD16-WITH-TRANSFORM))
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> COND IF IF IF IF THE SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 
; --> LET 
; ==>
;   #:G18
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-SEQUENCE-READER READ-SEQUENCE-CARD16 CARD16 (READ-LIST-CARD16 READ-LIST-CARD16-WITH-TRANSFORM) (READ-SIMPLE-ARRAY-CARD16 READ-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM) (READ-VECTOR-CARD16 READ-VECTOR-CARD16-WITH-TRANSFORM))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFINE-TRANSFORMED-SEQUENCE-READER READ-SEQUENCE-INT16
;     (XLIB::DEFINE-TRANSFORMED-SEQUENCE-READER XLIB::READ-SEQUENCE-INT16
;                                               XLIB:INT16 XLIB::CARD16->INT16
;                                               XLIB::READ-SEQUENCE-CARD16)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> COND IF IF IF IF THE SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 
; --> LET 
; ==>
;   #:G21
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-TRANSFORMED-SEQUENCE-READER READ-SEQUENCE-INT16 INT16 CARD16->INT16 READ-SEQUENCE-CARD16)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in:
;      DEFINE-LIST-READERS (READ-LIST-CARD32 READ-LIST-CARD32-WITH-TRANSFORM)
;     (XLIB::DEFINE-LIST-READERS
;      (XLIB::READ-LIST-CARD32 XLIB::READ-LIST-CARD32-WITH-TRANSFORM) XLIB:CARD32
;      32 4 XLIB::READ-CARD32)
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G44
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-LIST-READERS (READ-LIST-CARD32 READ-LIST-CARD32-WITH-TRANSFORM) CARD32 32 4 READ-CARD32)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN READ-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM
;     (DEFUN XLIB::READ-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM
;            (XLIB::REPLY-BUFFER XLIB::NITEMS XLIB::DATA XLIB::TRANSFORM
;             XLIB::START XLIB::INDEX)
;       (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER)
;                (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX)
;                (TYPE (SIMPLE-ARRAY XLIB:CARD32 (*)) XLIB::DATA))
;       (DECLARE (TYPE (FUNCTION (XLIB:CARD32) XLIB:CARD32) XLIB::TRANSFORM)
;                (DYNAMIC-EXTENT XLIB::TRANSFORM))
;       (XLIB::WITH-VECTOR (XLIB::DATA (SIMPLE-ARRAY XLIB:CARD32 (*)))
;         (XLIB::WITH-BUFFER-INPUT (XLIB::REPLY-BUFFER :SIZES (32) :INDEX
;                                   XLIB::INDEX)
;           (DO* (#
;                 #
;                 #)
;                (#)
;             (DECLARE #)
;             (SETF #)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G20
; 
; note: could not stack allocate TRANSFORM in: (DEFUN READ-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM (REPLY-BUFFER NITEMS DATA TRANSFORM START INDEX) (DECLARE (TYPE REPLY-BUFFER REPLY-BUFFER) (TYPE ARRAY-INDEX NITEMS START INDEX) (TYPE (SIMPLE-ARRAY CARD32 (*)) DATA)) (DECLARE (TYPE (FUNCTION (CARD32) CARD32) TRANSFORM) (DYNAMIC-EXTENT TRANSFORM)) (WITH-VECTOR (DATA (SIMPLE-ARRAY CARD32 (*))) (WITH-BUFFER-INPUT (REPLY-BUFFER :SIZES (32) :INDEX INDEX) (DO* ((J START (INDEX+ J 1)) (END (INDEX+ START NITEMS)) (INDEX 0 (INDEX+ INDEX 4))) ((INDEX>= J END)) (DECLARE (TYPE ARRAY-INDEX J END INDEX)) (SETF (AREF DATA J) (THE CARD32 (FUNCALL TRANSFORM (READ-CARD32 INDEX))))))))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN READ-VECTOR-CARD32
;     (SETF (AREF XLIB::DATA XLIB::J) (XLIB::READ-CARD32 XLIB::INDEX))
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN READ-VECTOR-CARD32-WITH-TRANSFORM
;     (SETF (AREF XLIB::DATA XLIB::J)
;             (FUNCALL XLIB::TRANSFORM (XLIB::READ-CARD32 XLIB::INDEX)))
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (DEFUN XLIB::READ-VECTOR-CARD32-WITH-TRANSFORM
;            (XLIB::REPLY-BUFFER XLIB::NITEMS XLIB::DATA XLIB::TRANSFORM
;             XLIB::START XLIB::INDEX)
;       (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER)
;                (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX)
;                (TYPE VECTOR XLIB::DATA)
;                (OPTIMIZE))
;       (DECLARE (TYPE (FUNCTION (XLIB:CARD32) T) XLIB::TRANSFORM)
;                (DYNAMIC-EXTENT XLIB::TRANSFORM))
;       (XLIB::WITH-VECTOR (XLIB::DATA VECTOR)
;         (XLIB::WITH-BUFFER-INPUT (XLIB::REPLY-BUFFER :SIZES (32) :INDEX
;                                   XLIB::INDEX)
;           (DO* (#
;                 #
;                 #)
;                (#)
;             (DECLARE #)
;             (SETF #)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G17
; 
; note: could not stack allocate TRANSFORM in: (DEFUN READ-VECTOR-CARD32-WITH-TRANSFORM (REPLY-BUFFER NITEMS DATA TRANSFORM START INDEX) (DECLARE (TYPE REPLY-BUFFER REPLY-BUFFER) (TYPE ARRAY-INDEX NITEMS START INDEX) (TYPE VECTOR DATA) (OPTIMIZE)) (DECLARE (TYPE (FUNCTION (CARD32) T) TRANSFORM) (DYNAMIC-EXTENT TRANSFORM)) (WITH-VECTOR (DATA VECTOR) (WITH-BUFFER-INPUT (REPLY-BUFFER :SIZES (32) :INDEX INDEX) (DO* ((J START (INDEX+ J 1)) (END (INDEX+ START NITEMS)) (INDEX 0 (INDEX+ INDEX 4))) ((INDEX>= J END)) (DECLARE (TYPE ARRAY-INDEX J END INDEX)) (SETF (AREF DATA J) (FUNCALL TRANSFORM (READ-CARD32 INDEX)))))))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFINE-SEQUENCE-READER READ-SEQUENCE-CARD32
;     (XLIB::DEFINE-SEQUENCE-READER XLIB::READ-SEQUENCE-CARD32 XLIB:CARD32
;                                   (XLIB::READ-LIST-CARD32
;                                    XLIB::READ-LIST-CARD32-WITH-TRANSFORM)
;                                   (XLIB::READ-SIMPLE-ARRAY-CARD32
;                                    XLIB::READ-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM)
;                                   (XLIB::READ-VECTOR-CARD32
;                                    XLIB::READ-VECTOR-CARD32-WITH-TRANSFORM))
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> COND IF IF IF IF THE SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 
; --> LET 
; ==>
;   #:G18
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-SEQUENCE-READER READ-SEQUENCE-CARD32 CARD32 (READ-LIST-CARD32 READ-LIST-CARD32-WITH-TRANSFORM) (READ-SIMPLE-ARRAY-CARD32 READ-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM) (READ-VECTOR-CARD32 READ-VECTOR-CARD32-WITH-TRANSFORM))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFINE-TRANSFORMED-SEQUENCE-READER READ-SEQUENCE-INT32
;     (XLIB::DEFINE-TRANSFORMED-SEQUENCE-READER XLIB::READ-SEQUENCE-INT32
;                                               XLIB:INT32 XLIB::CARD32->INT32
;                                               XLIB::READ-SEQUENCE-CARD32)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> COND IF IF IF IF THE SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 
; --> LET 
; ==>
;   #:G21
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-TRANSFORMED-SEQUENCE-READER READ-SEQUENCE-INT32 INT32 CARD32->INT32 READ-SEQUENCE-CARD32)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFINE-TRANSFORMED-SEQUENCE-WRITER WRITE-SEQUENCE-CHAR
;     (XLIB::DEFINE-TRANSFORMED-SEQUENCE-WRITER XLIB::WRITE-SEQUENCE-CHAR CHARACTER
;                                               XLIB:CHAR->CARD8
;                                               XLIB::WRITE-SEQUENCE-CARD8)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> COND IF IF IF THE SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G23
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-TRANSFORMED-SEQUENCE-WRITER WRITE-SEQUENCE-CHAR CHARACTER CHAR->CARD8 WRITE-SEQUENCE-CARD8)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in:
;      DEFINE-LIST-WRITERS (WRITE-LIST-CARD8 WRITE-LIST-CARD8-WITH-TRANSFORM)
;     (XLIB::DEFINE-LIST-WRITERS
;      (XLIB::WRITE-LIST-CARD8 XLIB::WRITE-LIST-CARD8-WITH-TRANSFORM) XLIB:CARD8 1
;      XLIB::WRITE-CARD8)
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G95
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-LIST-WRITERS (WRITE-LIST-CARD8 WRITE-LIST-CARD8-WITH-TRANSFORM) CARD8 1 WRITE-CARD8)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WRITE-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM
;     (DEFUN XLIB::WRITE-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM
;            (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END
;             XLIB::TRANSFORM)
;       (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER)
;                (TYPE (SIMPLE-ARRAY XLIB:CARD8 (*)) XLIB::DATA)
;                (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END))
;       (DECLARE (TYPE (FUNCTION (XLIB:CARD8) XLIB:CARD8) XLIB::TRANSFORM)
;                (DYNAMIC-EXTENT XLIB::TRANSFORM))
;       (XLIB::WITH-VECTOR (XLIB::DATA (SIMPLE-ARRAY XLIB:CARD8 (*)))
;         (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD8
;             ((XLIB::INDEX XLIB::START))
;             ((TYPE XLIB:ARRAY-INDEX XLIB::INDEX))
;           (DOTIMES (XLIB::J XLIB::CHUNK)
;             (DECLARE #)
;             (XLIB::WRITE-CARD8 XLIB::J #)
;             (SETQ #))))
;       NIL)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G39
; 
; note: could not stack allocate TRANSFORM in: (DEFUN WRITE-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM (BUFFER BOFFSET DATA START END TRANSFORM) (DECLARE (TYPE BUFFER BUFFER) (TYPE (SIMPLE-ARRAY CARD8 (*)) DATA) (TYPE ARRAY-INDEX BOFFSET START END)) (DECLARE (TYPE (FUNCTION (CARD8) CARD8) TRANSFORM) (DYNAMIC-EXTENT TRANSFORM)) (WITH-VECTOR (DATA (SIMPLE-ARRAY CARD8 (*))) (WRITING-BUFFER-CHUNKS CARD8 ((INDEX START)) ((TYPE ARRAY-INDEX INDEX)) (DOTIMES (J CHUNK) (DECLARE (TYPE ARRAY-INDEX J)) (WRITE-CARD8 J (FUNCALL TRANSFORM (AREF DATA INDEX))) (SETQ INDEX (INDEX+ INDEX 1))))) NIL)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WRITE-VECTOR-CARD8
;     (AREF XLIB::DATA XLIB::INDEX)
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WRITE-VECTOR-CARD8-WITH-TRANSFORM
;     (AREF XLIB::DATA XLIB::INDEX)
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (DEFUN XLIB::WRITE-VECTOR-CARD8-WITH-TRANSFORM
;            (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END
;             XLIB::TRANSFORM)
;       (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER)
;                (TYPE VECTOR XLIB::DATA)
;                (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END))
;       (DECLARE (TYPE (FUNCTION (T) XLIB:CARD8) XLIB::TRANSFORM)
;                (DYNAMIC-EXTENT XLIB::TRANSFORM))
;       (XLIB::WITH-VECTOR (XLIB::DATA VECTOR)
;         (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD8
;             ((XLIB::INDEX XLIB::START))
;             ((TYPE XLIB:ARRAY-INDEX XLIB::INDEX))
;           (DOTIMES (XLIB::J XLIB::CHUNK)
;             (DECLARE #)
;             (XLIB::WRITE-CARD8 XLIB::J #)
;             (SETQ #))))
;       NIL)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G39
; 
; note: could not stack allocate TRANSFORM in: (DEFUN WRITE-VECTOR-CARD8-WITH-TRANSFORM (BUFFER BOFFSET DATA START END TRANSFORM) (DECLARE (TYPE BUFFER BUFFER) (TYPE VECTOR DATA) (TYPE ARRAY-INDEX BOFFSET START END)) (DECLARE (TYPE (FUNCTION (T) CARD8) TRANSFORM) (DYNAMIC-EXTENT TRANSFORM)) (WITH-VECTOR (DATA VECTOR) (WRITING-BUFFER-CHUNKS CARD8 ((INDEX START)) ((TYPE ARRAY-INDEX INDEX)) (DOTIMES (J CHUNK) (DECLARE (TYPE ARRAY-INDEX J)) (WRITE-CARD8 J (FUNCALL TRANSFORM (AREF DATA INDEX))) (SETQ INDEX (INDEX+ INDEX 1))))) NIL)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFINE-SEQUENCE-WRITER WRITE-SEQUENCE-CARD8
;     (XLIB::DEFINE-SEQUENCE-WRITER XLIB::WRITE-SEQUENCE-CARD8 XLIB:CARD8
;                                   (XLIB::WRITE-LIST-CARD8
;                                    XLIB::WRITE-LIST-CARD8-WITH-TRANSFORM)
;                                   (XLIB::WRITE-SIMPLE-ARRAY-CARD8
;                                    XLIB::WRITE-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM)
;                                   (XLIB::WRITE-VECTOR-CARD8
;                                    XLIB::WRITE-VECTOR-CARD8-WITH-TRANSFORM))
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> COND IF IF IF THE SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G17
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-SEQUENCE-WRITER WRITE-SEQUENCE-CARD8 CARD8 (WRITE-LIST-CARD8 WRITE-LIST-CARD8-WITH-TRANSFORM) (WRITE-SIMPLE-ARRAY-CARD8 WRITE-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM) (WRITE-VECTOR-CARD8 WRITE-VECTOR-CARD8-WITH-TRANSFORM))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFINE-TRANSFORMED-SEQUENCE-WRITER WRITE-SEQUENCE-INT8
;     (XLIB::DEFINE-TRANSFORMED-SEQUENCE-WRITER XLIB::WRITE-SEQUENCE-INT8 XLIB:INT8
;                                               XLIB::INT8->CARD8
;                                               XLIB::WRITE-SEQUENCE-CARD8)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> COND IF IF IF THE SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G22
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-TRANSFORMED-SEQUENCE-WRITER WRITE-SEQUENCE-INT8 INT8 INT8->CARD8 WRITE-SEQUENCE-CARD8)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in:
;      DEFINE-LIST-WRITERS (WRITE-LIST-CARD16 WRITE-LIST-CARD16-WITH-TRANSFORM)
;     (XLIB::DEFINE-LIST-WRITERS
;      (XLIB::WRITE-LIST-CARD16 XLIB::WRITE-LIST-CARD16-WITH-TRANSFORM) XLIB:CARD16
;      2 XLIB::WRITE-CARD16)
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G87
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-LIST-WRITERS (WRITE-LIST-CARD16 WRITE-LIST-CARD16-WITH-TRANSFORM) CARD16 2 WRITE-CARD16)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WRITE-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM
;     (DEFUN XLIB::WRITE-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM
;            (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END
;             XLIB::TRANSFORM)
;       (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER)
;                (TYPE (SIMPLE-ARRAY XLIB:CARD16 (*)) XLIB::DATA)
;                (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END))
;       (DECLARE (TYPE (FUNCTION (XLIB:CARD16) XLIB:CARD16) XLIB::TRANSFORM)
;                (DYNAMIC-EXTENT XLIB::TRANSFORM))
;       (XLIB::WITH-VECTOR (XLIB::DATA (SIMPLE-ARRAY XLIB:CARD16 (*)))
;         (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD16
;             ((XLIB::INDEX XLIB::START))
;             ((TYPE XLIB:ARRAY-INDEX XLIB::INDEX))
;           (DO (#) (#) (DECLARE #) (XLIB::WRITE-CARD16 XLIB::J #) (SETQ #))))
;       NIL)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G35
; 
; note: could not stack allocate TRANSFORM in: (DEFUN WRITE-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM (BUFFER BOFFSET DATA START END TRANSFORM) (DECLARE (TYPE BUFFER BUFFER) (TYPE (SIMPLE-ARRAY CARD16 (*)) DATA) (TYPE ARRAY-INDEX BOFFSET START END)) (DECLARE (TYPE (FUNCTION (CARD16) CARD16) TRANSFORM) (DYNAMIC-EXTENT TRANSFORM)) (WITH-VECTOR (DATA (SIMPLE-ARRAY CARD16 (*))) (WRITING-BUFFER-CHUNKS CARD16 ((INDEX START)) ((TYPE ARRAY-INDEX INDEX)) (DO ((J 0 (INDEX+ J 2))) ((INDEX>= J CHUNK)) (DECLARE (TYPE ARRAY-INDEX J)) (WRITE-CARD16 J (FUNCALL TRANSFORM (AREF DATA INDEX))) (SETQ INDEX (INDEX+ INDEX 1))))) NIL)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WRITE-VECTOR-CARD16
;     (AREF XLIB::DATA XLIB::INDEX)
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WRITE-VECTOR-CARD16-WITH-TRANSFORM
;     (AREF XLIB::DATA XLIB::INDEX)
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (DEFUN XLIB::WRITE-VECTOR-CARD16-WITH-TRANSFORM
;            (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END
;             XLIB::TRANSFORM)
;       (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER)
;                (TYPE VECTOR XLIB::DATA)
;                (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)
;                (OPTIMIZE))
;       (DECLARE (TYPE (FUNCTION (T) XLIB:CARD16) XLIB::TRANSFORM)
;                (DYNAMIC-EXTENT XLIB::TRANSFORM))
;       (XLIB::WITH-VECTOR (XLIB::DATA VECTOR)
;         (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD16
;             ((XLIB::INDEX XLIB::START))
;             ((TYPE XLIB:ARRAY-INDEX XLIB::INDEX))
;           (DO (#) (#) (DECLARE #) (XLIB::WRITE-CARD16 XLIB::J #) (SETQ #))))
;       NIL)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G35
; 
; note: could not stack allocate TRANSFORM in: (DEFUN WRITE-VECTOR-CARD16-WITH-TRANSFORM (BUFFER BOFFSET DATA START END TRANSFORM) (DECLARE (TYPE BUFFER BUFFER) (TYPE VECTOR DATA) (TYPE ARRAY-INDEX BOFFSET START END) (OPTIMIZE)) (DECLARE (TYPE (FUNCTION (T) CARD16) TRANSFORM) (DYNAMIC-EXTENT TRANSFORM)) (WITH-VECTOR (DATA VECTOR) (WRITING-BUFFER-CHUNKS CARD16 ((INDEX START)) ((TYPE ARRAY-INDEX INDEX)) (DO ((J 0 (INDEX+ J 2))) ((INDEX>= J CHUNK)) (DECLARE (TYPE ARRAY-INDEX J)) (WRITE-CARD16 J (FUNCALL TRANSFORM (AREF DATA INDEX))) (SETQ INDEX (INDEX+ INDEX 1))))) NIL)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFINE-SEQUENCE-WRITER WRITE-SEQUENCE-CARD16
;     (XLIB::DEFINE-SEQUENCE-WRITER XLIB::WRITE-SEQUENCE-CARD16 XLIB:CARD16
;                                   (XLIB::WRITE-LIST-CARD16
;                                    XLIB::WRITE-LIST-CARD16-WITH-TRANSFORM)
;                                   (XLIB::WRITE-SIMPLE-ARRAY-CARD16
;                                    XLIB::WRITE-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM)
;                                   (XLIB::WRITE-VECTOR-CARD16
;                                    XLIB::WRITE-VECTOR-CARD16-WITH-TRANSFORM))
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> COND IF IF IF THE SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G17
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-SEQUENCE-WRITER WRITE-SEQUENCE-CARD16 CARD16 (WRITE-LIST-CARD16 WRITE-LIST-CARD16-WITH-TRANSFORM) (WRITE-SIMPLE-ARRAY-CARD16 WRITE-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM) (WRITE-VECTOR-CARD16 WRITE-VECTOR-CARD16-WITH-TRANSFORM))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in:
;      DEFINE-LIST-WRITERS (WRITE-LIST-INT16 WRITE-LIST-INT16-WITH-TRANSFORM)
;     (XLIB::DEFINE-LIST-WRITERS
;      (XLIB::WRITE-LIST-INT16 XLIB::WRITE-LIST-INT16-WITH-TRANSFORM) XLIB:INT16 2
;      XLIB::WRITE-INT16)
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G87
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-LIST-WRITERS (WRITE-LIST-INT16 WRITE-LIST-INT16-WITH-TRANSFORM) INT16 2 WRITE-INT16)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WRITE-SIMPLE-ARRAY-INT16-WITH-TRANSFORM
;     (DEFUN XLIB::WRITE-SIMPLE-ARRAY-INT16-WITH-TRANSFORM
;            (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END
;             XLIB::TRANSFORM)
;       (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER)
;                (TYPE (SIMPLE-ARRAY XLIB:INT16 (*)) XLIB::DATA)
;                (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END))
;       (DECLARE (TYPE (FUNCTION (XLIB:INT16) XLIB:INT16) XLIB::TRANSFORM)
;                (DYNAMIC-EXTENT XLIB::TRANSFORM))
;       (XLIB::WITH-VECTOR (XLIB::DATA (SIMPLE-ARRAY XLIB:INT16 (*)))
;         (XLIB::WRITING-BUFFER-CHUNKS XLIB:INT16
;             ((XLIB::INDEX XLIB::START))
;             ((TYPE XLIB:ARRAY-INDEX XLIB::INDEX))
;           (DO (#) (#) (DECLARE #) (XLIB::WRITE-INT16 XLIB::J #) (SETQ #))))
;       NIL)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G35
; 
; note: could not stack allocate TRANSFORM in: (DEFUN WRITE-SIMPLE-ARRAY-INT16-WITH-TRANSFORM (BUFFER BOFFSET DATA START END TRANSFORM) (DECLARE (TYPE BUFFER BUFFER) (TYPE (SIMPLE-ARRAY INT16 (*)) DATA) (TYPE ARRAY-INDEX BOFFSET START END)) (DECLARE (TYPE (FUNCTION (INT16) INT16) TRANSFORM) (DYNAMIC-EXTENT TRANSFORM)) (WITH-VECTOR (DATA (SIMPLE-ARRAY INT16 (*))) (WRITING-BUFFER-CHUNKS INT16 ((INDEX START)) ((TYPE ARRAY-INDEX INDEX)) (DO ((J 0 (INDEX+ J 2))) ((INDEX>= J CHUNK)) (DECLARE (TYPE ARRAY-INDEX J)) (WRITE-INT16 J (FUNCALL TRANSFORM (AREF DATA INDEX))) (SETQ INDEX (INDEX+ INDEX 1))))) NIL)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WRITE-VECTOR-INT16
;     (AREF XLIB::DATA XLIB::INDEX)
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WRITE-VECTOR-INT16-WITH-TRANSFORM
;     (AREF XLIB::DATA XLIB::INDEX)
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (DEFUN XLIB::WRITE-VECTOR-INT16-WITH-TRANSFORM
;            (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END
;             XLIB::TRANSFORM)
;       (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER)
;                (TYPE VECTOR XLIB::DATA)
;                (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)
;                (OPTIMIZE))
;       (DECLARE (TYPE (FUNCTION (T) XLIB:INT16) XLIB::TRANSFORM)
;                (DYNAMIC-EXTENT XLIB::TRANSFORM))
;       (XLIB::WITH-VECTOR (XLIB::DATA VECTOR)
;         (XLIB::WRITING-BUFFER-CHUNKS XLIB:INT16
;             ((XLIB::INDEX XLIB::START))
;             ((TYPE XLIB:ARRAY-INDEX XLIB::INDEX))
;           (DO (#) (#) (DECLARE #) (XLIB::WRITE-INT16 XLIB::J #) (SETQ #))))
;       NIL)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G35
; 
; note: could not stack allocate TRANSFORM in: (DEFUN WRITE-VECTOR-INT16-WITH-TRANSFORM (BUFFER BOFFSET DATA START END TRANSFORM) (DECLARE (TYPE BUFFER BUFFER) (TYPE VECTOR DATA) (TYPE ARRAY-INDEX BOFFSET START END) (OPTIMIZE)) (DECLARE (TYPE (FUNCTION (T) INT16) TRANSFORM) (DYNAMIC-EXTENT TRANSFORM)) (WITH-VECTOR (DATA VECTOR) (WRITING-BUFFER-CHUNKS INT16 ((INDEX START)) ((TYPE ARRAY-INDEX INDEX)) (DO ((J 0 (INDEX+ J 2))) ((INDEX>= J CHUNK)) (DECLARE (TYPE ARRAY-INDEX J)) (WRITE-INT16 J (FUNCALL TRANSFORM (AREF DATA INDEX))) (SETQ INDEX (INDEX+ INDEX 1))))) NIL)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFINE-SEQUENCE-WRITER WRITE-SEQUENCE-INT16
;     (XLIB::DEFINE-SEQUENCE-WRITER XLIB::WRITE-SEQUENCE-INT16 XLIB:INT16
;                                   (XLIB::WRITE-LIST-INT16
;                                    XLIB::WRITE-LIST-INT16-WITH-TRANSFORM)
;                                   (XLIB::WRITE-SIMPLE-ARRAY-INT16
;                                    XLIB::WRITE-SIMPLE-ARRAY-INT16-WITH-TRANSFORM)
;                                   (XLIB::WRITE-VECTOR-INT16
;                                    XLIB::WRITE-VECTOR-INT16-WITH-TRANSFORM))
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> COND IF IF IF THE SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G17
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-SEQUENCE-WRITER WRITE-SEQUENCE-INT16 INT16 (WRITE-LIST-INT16 WRITE-LIST-INT16-WITH-TRANSFORM) (WRITE-SIMPLE-ARRAY-INT16 WRITE-SIMPLE-ARRAY-INT16-WITH-TRANSFORM) (WRITE-VECTOR-INT16 WRITE-VECTOR-INT16-WITH-TRANSFORM))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in:
;      DEFINE-LIST-WRITERS (WRITE-LIST-CARD32 WRITE-LIST-CARD32-WITH-TRANSFORM)
;     (XLIB::DEFINE-LIST-WRITERS
;      (XLIB::WRITE-LIST-CARD32 XLIB::WRITE-LIST-CARD32-WITH-TRANSFORM) XLIB:CARD32
;      4 XLIB::WRITE-CARD32)
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G87
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-LIST-WRITERS (WRITE-LIST-CARD32 WRITE-LIST-CARD32-WITH-TRANSFORM) CARD32 4 WRITE-CARD32)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WRITE-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM
;     (DEFUN XLIB::WRITE-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM
;            (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END
;             XLIB::TRANSFORM)
;       (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER)
;                (TYPE (SIMPLE-ARRAY XLIB:CARD32 (*)) XLIB::DATA)
;                (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END))
;       (DECLARE (TYPE (FUNCTION (XLIB:CARD32) XLIB:CARD32) XLIB::TRANSFORM)
;                (DYNAMIC-EXTENT XLIB::TRANSFORM))
;       (XLIB::WITH-VECTOR (XLIB::DATA (SIMPLE-ARRAY XLIB:CARD32 (*)))
;         (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD32
;             ((XLIB::INDEX XLIB::START))
;             ((TYPE XLIB:ARRAY-INDEX XLIB::INDEX))
;           (DO (#) (#) (DECLARE #) (XLIB::WRITE-CARD32 XLIB::J #) (SETQ #))))
;       NIL)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G35
; 
; note: could not stack allocate TRANSFORM in: (DEFUN WRITE-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM (BUFFER BOFFSET DATA START END TRANSFORM) (DECLARE (TYPE BUFFER BUFFER) (TYPE (SIMPLE-ARRAY CARD32 (*)) DATA) (TYPE ARRAY-INDEX BOFFSET START END)) (DECLARE (TYPE (FUNCTION (CARD32) CARD32) TRANSFORM) (DYNAMIC-EXTENT TRANSFORM)) (WITH-VECTOR (DATA (SIMPLE-ARRAY CARD32 (*))) (WRITING-BUFFER-CHUNKS CARD32 ((INDEX START)) ((TYPE ARRAY-INDEX INDEX)) (DO ((J 0 (INDEX+ J 4))) ((INDEX>= J CHUNK)) (DECLARE (TYPE ARRAY-INDEX J)) (WRITE-CARD32 J (FUNCALL TRANSFORM (AREF DATA INDEX))) (SETQ INDEX (INDEX+ INDEX 1))))) NIL)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WRITE-VECTOR-CARD32
;     (AREF XLIB::DATA XLIB::INDEX)
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WRITE-VECTOR-CARD32-WITH-TRANSFORM
;     (AREF XLIB::DATA XLIB::INDEX)
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (DEFUN XLIB::WRITE-VECTOR-CARD32-WITH-TRANSFORM
;            (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END
;             XLIB::TRANSFORM)
;       (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER)
;                (TYPE VECTOR XLIB::DATA)
;                (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)
;                (OPTIMIZE))
;       (DECLARE (TYPE (FUNCTION (T) XLIB:CARD32) XLIB::TRANSFORM)
;                (DYNAMIC-EXTENT XLIB::TRANSFORM))
;       (XLIB::WITH-VECTOR (XLIB::DATA VECTOR)
;         (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD32
;             ((XLIB::INDEX XLIB::START))
;             ((TYPE XLIB:ARRAY-INDEX XLIB::INDEX))
;           (DO (#) (#) (DECLARE #) (XLIB::WRITE-CARD32 XLIB::J #) (SETQ #))))
;       NIL)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G35
; 
; note: could not stack allocate TRANSFORM in: (DEFUN WRITE-VECTOR-CARD32-WITH-TRANSFORM (BUFFER BOFFSET DATA START END TRANSFORM) (DECLARE (TYPE BUFFER BUFFER) (TYPE VECTOR DATA) (TYPE ARRAY-INDEX BOFFSET START END) (OPTIMIZE)) (DECLARE (TYPE (FUNCTION (T) CARD32) TRANSFORM) (DYNAMIC-EXTENT TRANSFORM)) (WITH-VECTOR (DATA VECTOR) (WRITING-BUFFER-CHUNKS CARD32 ((INDEX START)) ((TYPE ARRAY-INDEX INDEX)) (DO ((J 0 (INDEX+ J 4))) ((INDEX>= J CHUNK)) (DECLARE (TYPE ARRAY-INDEX J)) (WRITE-CARD32 J (FUNCALL TRANSFORM (AREF DATA INDEX))) (SETQ INDEX (INDEX+ INDEX 1))))) NIL)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFINE-SEQUENCE-WRITER WRITE-SEQUENCE-CARD32
;     (XLIB::DEFINE-SEQUENCE-WRITER XLIB::WRITE-SEQUENCE-CARD32 XLIB:CARD32
;                                   (XLIB::WRITE-LIST-CARD32
;                                    XLIB::WRITE-LIST-CARD32-WITH-TRANSFORM)
;                                   (XLIB::WRITE-SIMPLE-ARRAY-CARD32
;                                    XLIB::WRITE-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM)
;                                   (XLIB::WRITE-VECTOR-CARD32
;                                    XLIB::WRITE-VECTOR-CARD32-WITH-TRANSFORM))
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> COND IF IF IF THE SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G17
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-SEQUENCE-WRITER WRITE-SEQUENCE-CARD32 CARD32 (WRITE-LIST-CARD32 WRITE-LIST-CARD32-WITH-TRANSFORM) (WRITE-SIMPLE-ARRAY-CARD32 WRITE-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM) (WRITE-VECTOR-CARD32 WRITE-VECTOR-CARD32-WITH-TRANSFORM))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFINE-TRANSFORMED-SEQUENCE-WRITER WRITE-SEQUENCE-INT32
;     (XLIB::DEFINE-TRANSFORMED-SEQUENCE-WRITER XLIB::WRITE-SEQUENCE-INT32
;                                               XLIB:INT32 XLIB::INT32->CARD32
;                                               XLIB::WRITE-SEQUENCE-CARD32)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> COND IF IF IF THE SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G22
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-TRANSFORMED-SEQUENCE-WRITER WRITE-SEQUENCE-INT32 INT32 INT32->CARD32 WRITE-SEQUENCE-CARD32)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in:
;      DEFINE-LIST-WRITERS (WRITE-LIST-CHAR2B WRITE-LIST-CHAR2B-WITH-TRANSFORM)
;     (XLIB::DEFINE-LIST-WRITERS
;      (XLIB::WRITE-LIST-CHAR2B XLIB::WRITE-LIST-CHAR2B-WITH-TRANSFORM) XLIB:CARD16
;      2 XLIB::WRITE-CHAR2B)
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G109
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-LIST-WRITERS (WRITE-LIST-CHAR2B WRITE-LIST-CHAR2B-WITH-TRANSFORM) CARD16 2 WRITE-CHAR2B)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WRITE-SIMPLE-ARRAY-CHAR2B-WITH-TRANSFORM
;     (DEFUN XLIB::WRITE-SIMPLE-ARRAY-CHAR2B-WITH-TRANSFORM
;            (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END
;             XLIB::TRANSFORM)
;       (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER)
;                (TYPE (SIMPLE-ARRAY XLIB:CARD16 (*)) XLIB::DATA)
;                (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END))
;       (DECLARE (TYPE (FUNCTION (XLIB:CARD16) XLIB:CARD16) XLIB::TRANSFORM)
;                (DYNAMIC-EXTENT XLIB::TRANSFORM))
;       (XLIB::WITH-VECTOR (XLIB::DATA (SIMPLE-ARRAY XLIB:CARD16 (*)))
;         (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD16
;             ((XLIB::INDEX XLIB::START))
;             ((TYPE XLIB:ARRAY-INDEX XLIB::INDEX))
;           (DO (#) (# #) (DECLARE #) (XLIB::WRITE-CHAR2B XLIB::J #) (SETQ #))))
;       NIL)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G46
; 
; note: could not stack allocate TRANSFORM in: (DEFUN WRITE-SIMPLE-ARRAY-CHAR2B-WITH-TRANSFORM (BUFFER BOFFSET DATA START END TRANSFORM) (DECLARE (TYPE BUFFER BUFFER) (TYPE (SIMPLE-ARRAY CARD16 (*)) DATA) (TYPE ARRAY-INDEX BOFFSET START END)) (DECLARE (TYPE (FUNCTION (CARD16) CARD16) TRANSFORM) (DYNAMIC-EXTENT TRANSFORM)) (WITH-VECTOR (DATA (SIMPLE-ARRAY CARD16 (*))) (WRITING-BUFFER-CHUNKS CARD16 ((INDEX START)) ((TYPE ARRAY-INDEX INDEX)) (DO ((J 0 (INDEX+ J 2))) ((INDEX>= J (1- CHUNK)) (SETF CHUNK J)) (DECLARE (TYPE ARRAY-INDEX J)) (WRITE-CHAR2B J (FUNCALL TRANSFORM (AREF DATA INDEX))) (SETQ INDEX (INDEX+ INDEX 1))))) NIL)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WRITE-VECTOR-CHAR2B
;     (AREF XLIB::DATA XLIB::INDEX)
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFUN WRITE-VECTOR-CHAR2B-WITH-TRANSFORM
;     (AREF XLIB::DATA XLIB::INDEX)
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (DEFUN XLIB::WRITE-VECTOR-CHAR2B-WITH-TRANSFORM
;            (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END
;             XLIB::TRANSFORM)
;       (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER)
;                (TYPE VECTOR XLIB::DATA)
;                (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)
;                (OPTIMIZE))
;       (DECLARE (TYPE (FUNCTION (T) XLIB:CARD16) XLIB::TRANSFORM)
;                (DYNAMIC-EXTENT XLIB::TRANSFORM))
;       (XLIB::WITH-VECTOR (XLIB::DATA VECTOR)
;         (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD16
;             ((XLIB::INDEX XLIB::START))
;             ((TYPE XLIB:ARRAY-INDEX XLIB::INDEX))
;           (DO (#) (# #) (DECLARE #) (XLIB::WRITE-CHAR2B XLIB::J #) (SETQ #))))
;       NIL)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G46
; 
; note: could not stack allocate TRANSFORM in: (DEFUN WRITE-VECTOR-CHAR2B-WITH-TRANSFORM (BUFFER BOFFSET DATA START END TRANSFORM) (DECLARE (TYPE BUFFER BUFFER) (TYPE VECTOR DATA) (TYPE ARRAY-INDEX BOFFSET START END) (OPTIMIZE)) (DECLARE (TYPE (FUNCTION (T) CARD16) TRANSFORM) (DYNAMIC-EXTENT TRANSFORM)) (WITH-VECTOR (DATA VECTOR) (WRITING-BUFFER-CHUNKS CARD16 ((INDEX START)) ((TYPE ARRAY-INDEX INDEX)) (DO ((J 0 (INDEX+ J 2))) ((INDEX>= J (1- CHUNK)) (SETF CHUNK J)) (DECLARE (TYPE ARRAY-INDEX J)) (WRITE-CHAR2B J (FUNCALL TRANSFORM (AREF DATA INDEX))) (SETQ INDEX (INDEX+ INDEX 1))))) NIL)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/buffer.lisp
; in: DEFINE-SEQUENCE-WRITER WRITE-SEQUENCE-CHAR2B
;     (XLIB::DEFINE-SEQUENCE-WRITER XLIB::WRITE-SEQUENCE-CHAR2B XLIB:CARD16
;                                   (XLIB::WRITE-LIST-CHAR2B
;                                    XLIB::WRITE-LIST-CHAR2B-WITH-TRANSFORM)
;                                   (XLIB::WRITE-SIMPLE-ARRAY-CHAR2B
;                                    XLIB::WRITE-SIMPLE-ARRAY-CHAR2B-WITH-TRANSFORM)
;                                   (XLIB::WRITE-VECTOR-CHAR2B
;                                    XLIB::WRITE-VECTOR-CHAR2B-WITH-TRANSFORM))
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> COND IF IF IF THE SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G17
; 
; note: could not stack allocate TRANSFORM in: (DEFINE-SEQUENCE-WRITER WRITE-SEQUENCE-CHAR2B CARD16 (WRITE-LIST-CHAR2B WRITE-LIST-CHAR2B-WITH-TRANSFORM) (WRITE-SIMPLE-ARRAY-CHAR2B WRITE-SIMPLE-ARRAY-CHAR2B-WITH-TRANSFORM) (WRITE-VECTOR-CHAR2B WRITE-VECTOR-CHAR2B-WITH-TRANSFORM))
; in:
;      DEFUN #S(SB-IMPL::COMMA :EXPR (XINTERN (QUOTE LOOKUP-) TYPE) :KIND 0)
;     (MEMBER TYPE '(XLIB:WINDOW XLIB:PIXMAP))
; ==>
;   TYPE
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/display.lisp
; in: DEFUN WITH-EVENT-QUEUE-FUNCTION
;     (DEFUN XLIB::WITH-EVENT-QUEUE-FUNCTION (XLIB:DISPLAY XLIB::TIMEOUT FUNCTION)
;       (DECLARE (TYPE XLIB:DISPLAY XLIB:DISPLAY)
;                (TYPE (OR NULL NUMBER) XLIB::TIMEOUT)
;                (TYPE FUNCTION FUNCTION)
;                (DYNAMIC-EXTENT FUNCTION)
;                (IGNORABLE XLIB:DISPLAY XLIB::TIMEOUT))
;       (XLIB:WITH-EVENT-QUEUE (XLIB:DISPLAY :TIMEOUT XLIB::TIMEOUT :INLINE T)
;         (FUNCALL FUNCTION)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G24
; 
; note: could not stack allocate FUNCTION in: (DEFUN WITH-EVENT-QUEUE-FUNCTION (DISPLAY TIMEOUT FUNCTION) (DECLARE (TYPE DISPLAY DISPLAY) (TYPE (OR NULL NUMBER) TIMEOUT) (TYPE FUNCTION FUNCTION) (DYNAMIC-EXTENT FUNCTION) (IGNORABLE DISPLAY TIMEOUT)) (WITH-EVENT-QUEUE (DISPLAY :TIMEOUT TIMEOUT :INLINE T) (FUNCALL FUNCTION)))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/display.lisp
; in: DEFUN DISPLAY-CONNECT
;     (LENGTH XLIB::AUTHORIZATION-NAME)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (LENGTH XLIB::AUTHORIZATION-DATA)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (LENGTH XLIB::AUTHORIZATION-NAME)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/gcontext.lisp
; in: DEFUN FORCE-GCONTEXT-CHANGES-INTERNAL
;     (LENGTH XLIB::LOCAL-DASH)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-SETDASHES+)
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       (XLIB:CARD16 (OR (XLIB::GCONTEXT-INTERNAL-DASH-OFFSET XLIB::LOCAL-STATE) 0)
;        (LENGTH XLIB::LOCAL-DASH))
;       ((SEQUENCE :FORMAT XLIB:CARD8) XLIB::LOCAL-DASH))
; --> LET XLIB::WITH-BUFFER PROGN MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS 
; --> PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET 
; --> LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::LOCAL-DASH)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS VECTOR SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS VECTOR SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

;     (FUNCALL (XLIB::GCONTEXT-EXTENSION-SET-FUNCTION (CAR XLIB::EXTENSION))
;              XLIB:GCONTEXT XLIB::LOCAL)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN
;    (XLIB::GCONTEXT-EXTENSION-SET-FUNCTION (CAR XLIB::EXTENSION)))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-SETCLIPRECTANGLES+)
;       (XLIB::DATA (FIRST XLIB::LOCAL-CLIP))
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       (XLIB:CARD16 (OR (XLIB::GCONTEXT-INTERNAL-CLIP-X XLIB::LOCAL-STATE) 0)
;        (OR (XLIB::GCONTEXT-INTERNAL-CLIP-Y XLIB::LOCAL-STATE) 0))
;       ((SEQUENCE :FORMAT XLIB:INT16) (SECOND XLIB::LOCAL-CLIP)))
; --> LET XLIB::WITH-BUFFER PROGN MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS 
; --> PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET 
; --> LET* XLIB::CHECK-PUT LET XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::.VALUE.)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (EQL (SVREF XLIB::SERVER-STATE XLIB::I)
;          (SETQ XLIB::LOCAL (SVREF XLIB::LOCAL-STATE XLIB::I)))
; 
; note: forced to do GENERIC-EQL (cost 10)
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/gcontext.lisp
; in: DEFUN COPY-GCONTEXT-LOCAL-STATE
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:GCONTEXT 'XLIB:GCONTEXT)
; --> XLIB:WITH-DISPLAY XLIB::WITH-BUFFER PROGN FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN (XLIB:DISPLAY-XID XLIB:DISPLAY))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

;     (- XLIB::*GCONTEXT-DATA-LENGTH*)
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER XLIB::*GCONTEXT-DATA-LENGTH*))
; 
; note: unable to Eliminate %negate/%negate of rationals due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (ELT XLIB::*GCONTEXT-EXTENSIONS* XLIB::I)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a LIST.

;     (FUNCALL XLIB::COPY-FUNCTION XLIB:GCONTEXT XLIB::TEMP-GC
;              (SVREF XLIB::LOCAL-STATE
;                     (XLIB::INDEX+ XLIB::I XLIB::*GCONTEXT-DATA-LENGTH*)))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN XLIB::COPY-FUNCTION)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

;     (- XLIB::*GCONTEXT-DATA-LENGTH*)
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER XLIB::*GCONTEXT-DATA-LENGTH*))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (ASH XLIB::EXTENSION-MASK (- XLIB::*GCONTEXT-DATA-LENGTH*))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (ASH BIT -1)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/gcontext.lisp
; in: DEFUN RESTORE-GCONTEXT-TEMP-STATE
;     (- XLIB::*GCONTEXT-DATA-LENGTH*)
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER XLIB::*GCONTEXT-DATA-LENGTH*))
; 
; note: unable to Eliminate %negate/%negate of rationals due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (FUNCALL XLIB::COPY-FUNCTION XLIB::TEMP-GC XLIB:GCONTEXT
;              (SVREF XLIB::LOCAL-STATE XLIB::I))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN XLIB::COPY-FUNCTION)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

;     (- XLIB::*GCONTEXT-DATA-LENGTH*)
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER XLIB::*GCONTEXT-DATA-LENGTH*))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (ASH XLIB::TEMP-MASK (- XLIB::*GCONTEXT-DATA-LENGTH*))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (ASH BIT -1)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/gcontext.lisp
; in: DEFUN CREATE-GCONTEXT
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:GCONTEXT 'XLIB:GCONTEXT)
; --> XLIB:WITH-DISPLAY XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN (XLIB:DISPLAY-XID XLIB:DISPLAY))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/gcontext.lisp
; in: DEFUN COPY-GCONTEXT-COMPONENTS
;     (FIND XLIB::KEY XLIB::*GCONTEXT-EXTENSIONS* :KEY
;           #'XLIB::GCONTEXT-EXTENSION-NAME)
; 
; note: unable to optimize due to type uncertainty: The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

;     (FUNCALL (XLIB::GCONTEXT-EXTENSION-COPY-FUNCTION XLIB::EXTENSION) XLIB::SRC
;              XLIB::DST
;              (SVREF (XLIB::GCONTEXT-LOCAL-STATE XLIB::SRC)
;                     (XLIB::INDEX+
;                      (POSITION XLIB::EXTENSION XLIB::*GCONTEXT-EXTENSIONS*)
;                      XLIB::*GCONTEXT-DATA-LENGTH*)))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN
;    (XLIB::GCONTEXT-EXTENSION-COPY-FUNCTION XLIB::EXTENSION))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

;     (POSITION XLIB::EXTENSION XLIB::*GCONTEXT-EXTENSIONS*)
; 
; note: unable to optimize due to type uncertainty: The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DEFUN QUEUE-EVENT
;     (APPLY (SVREF XLIB::*EVENT-SEND-VECTOR* XLIB::EVENT-CODE) XLIB:DISPLAY
;            XLIB::ARGS)
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN
;    (SVREF XLIB::*EVENT-SEND-VECTOR* XLIB::EVENT-CODE))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in:
;      DECLARE-EVENT (:KEY-PRESS :KEY-RELEASE :BUTTON-PRESS :BUTTON-RELEASE)
;     (XLIB:DECLARE-EVENT (:KEY-PRESS :KEY-RELEASE :BUTTON-PRESS :BUTTON-RELEASE)
;       (XLIB::DATA XLIB::CODE)
;       (XLIB:CARD16 SEQUENCE)
;       ((OR NULL XLIB:CARD32) TIME)
;       (XLIB:WINDOW XLIB::ROOT (XLIB:WINDOW XLIB::EVENT-WINDOW))
;       ((OR NULL XLIB:WINDOW) XLIB::CHILD)
;       (XLIB:INT16 XLIB::ROOT-X XLIB::ROOT-Y XLIB::X XLIB::Y)
;       (XLIB:CARD16 XLIB::STATE)
;       (BOOLEAN XLIB::SAME-SCREEN-P))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G55
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT (:KEY-PRESS :KEY-RELEASE :BUTTON-PRESS :BUTTON-RELEASE) (DATA CODE) (CARD16 SEQUENCE) ((OR NULL CARD32) TIME) (WINDOW ROOT (WINDOW EVENT-WINDOW)) ((OR NULL WINDOW) CHILD) (INT16 ROOT-X ROOT-Y X Y) (CARD16 STATE) (BOOLEAN SAME-SCREEN-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :MOTION-NOTIFY
;     (XLIB:DECLARE-EVENT :MOTION-NOTIFY
;       ((XLIB::DATA BOOLEAN) XLIB::HINT-P)
;       (XLIB:CARD16 SEQUENCE)
;       ((OR NULL XLIB:CARD32) TIME)
;       (XLIB:WINDOW XLIB::ROOT (XLIB:WINDOW XLIB::EVENT-WINDOW))
;       ((OR NULL XLIB:WINDOW) XLIB::CHILD)
;       (XLIB:INT16 XLIB::ROOT-X XLIB::ROOT-Y XLIB::X XLIB::Y)
;       (XLIB:CARD16 XLIB::STATE)
;       (BOOLEAN XLIB::SAME-SCREEN-P))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G55
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :MOTION-NOTIFY ((DATA BOOLEAN) HINT-P) (CARD16 SEQUENCE) ((OR NULL CARD32) TIME) (WINDOW ROOT (WINDOW EVENT-WINDOW)) ((OR NULL WINDOW) CHILD) (INT16 ROOT-X ROOT-Y X Y) (CARD16 STATE) (BOOLEAN SAME-SCREEN-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT (:ENTER-NOTIFY :LEAVE-NOTIFY)
;     (XLIB:DECLARE-EVENT (:ENTER-NOTIFY :LEAVE-NOTIFY)
;       ((XLIB::DATA
;         (XLIB::MEMBER8 :ANCESTOR :VIRTUAL :INFERIOR :NONLINEAR
;          :NONLINEAR-VIRTUAL))
;        XLIB::KIND)
;       (XLIB:CARD16 SEQUENCE)
;       ((OR NULL XLIB:CARD32) TIME)
;       (XLIB:WINDOW XLIB::ROOT (XLIB:WINDOW XLIB::EVENT-WINDOW))
;       ((OR NULL XLIB:WINDOW) XLIB::CHILD)
;       (XLIB:INT16 XLIB::ROOT-X XLIB::ROOT-Y XLIB::X XLIB::Y)
;       (XLIB:CARD16 XLIB::STATE)
;       ((XLIB::MEMBER8 :NORMAL :GRAB :UNGRAB) XLIB::MODE)
;       ((BIT 0) XLIB::FOCUS-P)
;       ((BIT 1) XLIB::SAME-SCREEN-P))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G63
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT (:ENTER-NOTIFY :LEAVE-NOTIFY) ((DATA (MEMBER8 :ANCESTOR :VIRTUAL :INFERIOR :NONLINEAR :NONLINEAR-VIRTUAL)) KIND) (CARD16 SEQUENCE) ((OR NULL CARD32) TIME) (WINDOW ROOT (WINDOW EVENT-WINDOW)) ((OR NULL WINDOW) CHILD) (INT16 ROOT-X ROOT-Y X Y) (CARD16 STATE) ((MEMBER8 :NORMAL :GRAB :UNGRAB) MODE) ((BIT 0) FOCUS-P) ((BIT 1) SAME-SCREEN-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT (:FOCUS-IN :FOCUS-OUT)
;     (XLIB:DECLARE-EVENT (:FOCUS-IN :FOCUS-OUT)
;       ((XLIB::DATA
;         (XLIB::MEMBER8 :ANCESTOR :VIRTUAL :INFERIOR :NONLINEAR :NONLINEAR-VIRTUAL
;          :POINTER :POINTER-ROOT :NONE))
;        XLIB::KIND)
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW))
;       ((XLIB::MEMBER8 :NORMAL :WHILE-GRABBED :GRAB :UNGRAB) XLIB::MODE))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G46
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT (:FOCUS-IN :FOCUS-OUT) ((DATA (MEMBER8 :ANCESTOR :VIRTUAL :INFERIOR :NONLINEAR :NONLINEAR-VIRTUAL :POINTER :POINTER-ROOT :NONE)) KIND) (CARD16 SEQUENCE) (WINDOW (WINDOW EVENT-WINDOW)) ((MEMBER8 :NORMAL :WHILE-GRABBED :GRAB :UNGRAB) MODE))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :KEYMAP-NOTIFY
;     (XLIB:DECLARE-EVENT :KEYMAP-NOTIFY
;       ((XLIB::BIT-VECTOR256 0) XLIB::KEYMAP))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G35
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :KEYMAP-NOTIFY ((BIT-VECTOR256 0) KEYMAP))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :EXPOSURE
;     (XLIB:DECLARE-EVENT :EXPOSURE
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW))
;       (XLIB:CARD16 XLIB::X XLIB::Y XLIB::WIDTH XLIB::HEIGHT COUNT))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G43
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :EXPOSURE (CARD16 SEQUENCE) (WINDOW (WINDOW EVENT-WINDOW)) (CARD16 X Y WIDTH HEIGHT COUNT))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :GRAPHICS-EXPOSURE
;     (XLIB:DECLARE-EVENT :GRAPHICS-EXPOSURE
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:DRAWABLE (XLIB:DRAWABLE XLIB::EVENT-WINDOW))
;       (XLIB:CARD16 XLIB::X XLIB::Y XLIB::WIDTH XLIB::HEIGHT)
;       (XLIB:CARD16 XLIB::MINOR)
;       (XLIB:CARD16 COUNT)
;       (XLIB:CARD8 XLIB::MAJOR))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G45
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :GRAPHICS-EXPOSURE (CARD16 SEQUENCE) (DRAWABLE (DRAWABLE EVENT-WINDOW)) (CARD16 X Y WIDTH HEIGHT) (CARD16 MINOR) (CARD16 COUNT) (CARD8 MAJOR))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :NO-EXPOSURE
;     (XLIB:DECLARE-EVENT :NO-EXPOSURE
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:DRAWABLE (XLIB:DRAWABLE XLIB::EVENT-WINDOW))
;       (XLIB:CARD16 XLIB::MINOR)
;       (XLIB:CARD8 XLIB::MAJOR))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G40
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :NO-EXPOSURE (CARD16 SEQUENCE) (DRAWABLE (DRAWABLE EVENT-WINDOW)) (CARD16 MINOR) (CARD8 MAJOR))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :VISIBILITY-NOTIFY
;     (XLIB:DECLARE-EVENT :VISIBILITY-NOTIFY
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW))
;       ((XLIB::MEMBER8 :UNOBSCURED :PARTIALLY-OBSCURED :FULLY-OBSCURED)
;        XLIB::STATE))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G42
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :VISIBILITY-NOTIFY (CARD16 SEQUENCE) (WINDOW (WINDOW EVENT-WINDOW)) ((MEMBER8 :UNOBSCURED :PARTIALLY-OBSCURED :FULLY-OBSCURED) STATE))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :CREATE-NOTIFY
;     (XLIB:DECLARE-EVENT :CREATE-NOTIFY
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW (XLIB::PARENT XLIB::EVENT-WINDOW) XLIB:WINDOW)
;       (XLIB:INT16 XLIB::X XLIB::Y)
;       (XLIB:CARD16 XLIB::WIDTH XLIB::HEIGHT XLIB::BORDER-WIDTH)
;       (BOOLEAN XLIB::OVERRIDE-REDIRECT-P))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G45
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :CREATE-NOTIFY (CARD16 SEQUENCE) (WINDOW (PARENT EVENT-WINDOW) WINDOW) (INT16 X Y) (CARD16 WIDTH HEIGHT BORDER-WIDTH) (BOOLEAN OVERRIDE-REDIRECT-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :DESTROY-NOTIFY
;     (XLIB:DECLARE-EVENT :DESTROY-NOTIFY
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW XLIB::EVENT-WINDOW XLIB:WINDOW))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G38
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :DESTROY-NOTIFY (CARD16 SEQUENCE) (WINDOW EVENT-WINDOW WINDOW))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :UNMAP-NOTIFY
;     (XLIB:DECLARE-EVENT :UNMAP-NOTIFY
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW XLIB::EVENT-WINDOW XLIB:WINDOW)
;       (BOOLEAN XLIB::CONFIGURE-P))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G39
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :UNMAP-NOTIFY (CARD16 SEQUENCE) (WINDOW EVENT-WINDOW WINDOW) (BOOLEAN CONFIGURE-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :MAP-NOTIFY
;     (XLIB:DECLARE-EVENT :MAP-NOTIFY
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW XLIB::EVENT-WINDOW XLIB:WINDOW)
;       (BOOLEAN XLIB::OVERRIDE-REDIRECT-P))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G39
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :MAP-NOTIFY (CARD16 SEQUENCE) (WINDOW EVENT-WINDOW WINDOW) (BOOLEAN OVERRIDE-REDIRECT-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :MAP-REQUEST
;     (XLIB:DECLARE-EVENT :MAP-REQUEST
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW (XLIB::PARENT XLIB::EVENT-WINDOW) XLIB:WINDOW))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G39
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :MAP-REQUEST (CARD16 SEQUENCE) (WINDOW (PARENT EVENT-WINDOW) WINDOW))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :REPARENT-NOTIFY
;     (XLIB:DECLARE-EVENT :REPARENT-NOTIFY
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW XLIB::EVENT-WINDOW XLIB:WINDOW XLIB::PARENT)
;       (XLIB:INT16 XLIB::X XLIB::Y)
;       (BOOLEAN XLIB::OVERRIDE-REDIRECT-P))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G42
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :REPARENT-NOTIFY (CARD16 SEQUENCE) (WINDOW EVENT-WINDOW WINDOW PARENT) (INT16 X Y) (BOOLEAN OVERRIDE-REDIRECT-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :CONFIGURE-NOTIFY
;     (XLIB:DECLARE-EVENT :CONFIGURE-NOTIFY
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW XLIB::EVENT-WINDOW XLIB:WINDOW)
;       ((OR NULL XLIB:WINDOW) XLIB::ABOVE-SIBLING)
;       (XLIB:INT16 XLIB::X XLIB::Y)
;       (XLIB:CARD16 XLIB::WIDTH XLIB::HEIGHT XLIB::BORDER-WIDTH)
;       (BOOLEAN XLIB::OVERRIDE-REDIRECT-P))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G48
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :CONFIGURE-NOTIFY (CARD16 SEQUENCE) (WINDOW EVENT-WINDOW WINDOW) ((OR NULL WINDOW) ABOVE-SIBLING) (INT16 X Y) (CARD16 WIDTH HEIGHT BORDER-WIDTH) (BOOLEAN OVERRIDE-REDIRECT-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :CONFIGURE-REQUEST
;     (XLIB:DECLARE-EVENT :CONFIGURE-REQUEST
;       ((XLIB::DATA (XLIB::MEMBER8 :ABOVE :BELOW :TOP-IF :BOTTOM-IF :OPPOSITE))
;        XLIB::STACK-MODE)
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW (XLIB::PARENT XLIB::EVENT-WINDOW) XLIB:WINDOW)
;       ((OR NULL XLIB:WINDOW) XLIB::ABOVE-SIBLING)
;       (XLIB:INT16 XLIB::X XLIB::Y)
;       (XLIB:CARD16 XLIB::WIDTH XLIB::HEIGHT XLIB::BORDER-WIDTH XLIB::VALUE-MASK))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G53
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :CONFIGURE-REQUEST ((DATA (MEMBER8 :ABOVE :BELOW :TOP-IF :BOTTOM-IF :OPPOSITE)) STACK-MODE) (CARD16 SEQUENCE) (WINDOW (PARENT EVENT-WINDOW) WINDOW) ((OR NULL WINDOW) ABOVE-SIBLING) (INT16 X Y) (CARD16 WIDTH HEIGHT BORDER-WIDTH VALUE-MASK))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :GRAVITY-NOTIFY
;     (XLIB:DECLARE-EVENT :GRAVITY-NOTIFY
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW XLIB::EVENT-WINDOW XLIB:WINDOW)
;       (XLIB:INT16 XLIB::X XLIB::Y))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G40
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :GRAVITY-NOTIFY (CARD16 SEQUENCE) (WINDOW EVENT-WINDOW WINDOW) (INT16 X Y))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :RESIZE-REQUEST
;     (XLIB:DECLARE-EVENT :RESIZE-REQUEST
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW))
;       (XLIB:CARD16 XLIB::WIDTH XLIB::HEIGHT))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G40
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :RESIZE-REQUEST (CARD16 SEQUENCE) (WINDOW (WINDOW EVENT-WINDOW)) (CARD16 WIDTH HEIGHT))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :CIRCULATE-NOTIFY
;     (XLIB:DECLARE-EVENT :CIRCULATE-NOTIFY
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW XLIB::EVENT-WINDOW XLIB:WINDOW XLIB::PARENT)
;       ((XLIB::MEMBER8 :TOP :BOTTOM) XLIB::PLACE))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G43
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :CIRCULATE-NOTIFY (CARD16 SEQUENCE) (WINDOW EVENT-WINDOW WINDOW PARENT) ((MEMBER8 :TOP :BOTTOM) PLACE))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :CIRCULATE-REQUEST
;     (XLIB:DECLARE-EVENT :CIRCULATE-REQUEST
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW (XLIB::PARENT XLIB::EVENT-WINDOW) XLIB:WINDOW)
;       (XLIB::PAD16 1 2)
;       ((XLIB::MEMBER8 :TOP :BOTTOM) XLIB::PLACE))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G43
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :CIRCULATE-REQUEST (CARD16 SEQUENCE) (WINDOW (PARENT EVENT-WINDOW) WINDOW) (PAD16 1 2) ((MEMBER8 :TOP :BOTTOM) PLACE))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :PROPERTY-NOTIFY
;     (XLIB:DECLARE-EVENT :PROPERTY-NOTIFY
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW))
;       (KEYWORD ATOM)
;       ((OR NULL XLIB:CARD32) TIME)
;       ((XLIB::MEMBER8 :NEW-VALUE :DELETED) XLIB::STATE))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G48
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :PROPERTY-NOTIFY (CARD16 SEQUENCE) (WINDOW (WINDOW EVENT-WINDOW)) (KEYWORD ATOM) ((OR NULL CARD32) TIME) ((MEMBER8 :NEW-VALUE :DELETED) STATE))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :SELECTION-CLEAR
;     (XLIB:DECLARE-EVENT :SELECTION-CLEAR
;       (XLIB:CARD16 SEQUENCE)
;       ((OR NULL XLIB:CARD32) TIME)
;       (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW))
;       (KEYWORD XLIB::SELECTION))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G44
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :SELECTION-CLEAR (CARD16 SEQUENCE) ((OR NULL CARD32) TIME) (WINDOW (WINDOW EVENT-WINDOW)) (KEYWORD SELECTION))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :SELECTION-REQUEST
;     (XLIB:DECLARE-EVENT :SELECTION-REQUEST
;       (XLIB:CARD16 SEQUENCE)
;       ((OR NULL XLIB:CARD32) TIME)
;       (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW) XLIB::REQUESTOR)
;       (KEYWORD XLIB::SELECTION XLIB::TARGET)
;       ((OR NULL KEYWORD) XLIB::PROPERTY))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G50
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :SELECTION-REQUEST (CARD16 SEQUENCE) ((OR NULL CARD32) TIME) (WINDOW (WINDOW EVENT-WINDOW) REQUESTOR) (KEYWORD SELECTION TARGET) ((OR NULL KEYWORD) PROPERTY))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :SELECTION-NOTIFY
;     (XLIB:DECLARE-EVENT :SELECTION-NOTIFY
;       (XLIB:CARD16 SEQUENCE)
;       ((OR NULL XLIB:CARD32) TIME)
;       (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW))
;       (KEYWORD XLIB::SELECTION XLIB::TARGET)
;       ((OR NULL KEYWORD) XLIB::PROPERTY))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G49
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :SELECTION-NOTIFY (CARD16 SEQUENCE) ((OR NULL CARD32) TIME) (WINDOW (WINDOW EVENT-WINDOW)) (KEYWORD SELECTION TARGET) ((OR NULL KEYWORD) PROPERTY))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :COLORMAP-NOTIFY
;     (XLIB:DECLARE-EVENT :COLORMAP-NOTIFY
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW))
;       ((OR NULL XLIB:COLORMAP) XLIB:COLORMAP)
;       (BOOLEAN XLIB::NEW-P XLIB::INSTALLED-P))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G44
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :COLORMAP-NOTIFY (CARD16 SEQUENCE) (WINDOW (WINDOW EVENT-WINDOW)) ((OR NULL COLORMAP) COLORMAP) (BOOLEAN NEW-P INSTALLED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :CLIENT-MESSAGE
;     (XLIB:DECLARE-EVENT :CLIENT-MESSAGE
;       (XLIB::DATA FORMAT)
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW))
;       (KEYWORD TYPE)
;       ((XLIB::CLIENT-MESSAGE-SEQUENCE FORMAT) XLIB::DATA))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION BLOCK XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* FUNCALL SB-C::%FUNCALL 
; --> XLIB::CLIENT-MESSAGE-SEQUENCE-GET XLIB::CLIENT-MESSAGE-EVENT-GET-SEQUENCE 
; --> LET* 
; ==>
;   (MAKE-ARRAY (CEILING 160 FORMAT) :ELEMENT-TYPE `(UNSIGNED-BYTE ,FORMAT))
; 
; note: unable to optimize because: ELEMENT-TYPE is not constant.

; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION BLOCK XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* FUNCALL SB-C::%FUNCALL 
; --> XLIB::CLIENT-MESSAGE-SEQUENCE-GET XLIB::CLIENT-MESSAGE-EVENT-GET-SEQUENCE 
; --> LET* DO BLOCK LET TAGBODY TAGBODY CASE LET COND IF PROGN SETF LET* 
; --> FUNCALL SB-C::%FUNCALL (SETF AREF) 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (SIMPLE-ARRAY * (*)), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.

; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION BLOCK XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* FUNCALL SB-C::%FUNCALL 
; --> XLIB::CLIENT-MESSAGE-SEQUENCE-GET XLIB::CLIENT-MESSAGE-EVENT-GET-SEQUENCE 
; --> LET* DO BLOCK LET TAGBODY TAGBODY CASE LET COND IF IF PROGN SETF LET* 
; --> FUNCALL SB-C::%FUNCALL (SETF AREF) 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (SIMPLE-ARRAY * (*)), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.

; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION BLOCK XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* FUNCALL SB-C::%FUNCALL 
; --> XLIB::CLIENT-MESSAGE-SEQUENCE-GET XLIB::CLIENT-MESSAGE-EVENT-GET-SEQUENCE 
; --> LET* DO BLOCK LET TAGBODY TAGBODY CASE LET COND IF IF IF PROGN SETF LET* 
; --> FUNCALL SB-C::%FUNCALL (SETF AREF) 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (SIMPLE-ARRAY * (*)), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.

; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G67
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :CLIENT-MESSAGE (DATA FORMAT) (CARD16 SEQUENCE) (WINDOW (WINDOW EVENT-WINDOW)) (KEYWORD TYPE) ((CLIENT-MESSAGE-SEQUENCE FORMAT) DATA))

; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION BLOCK XLIB::WITH-BUFFER-OUTPUT LET LET* 
; --> XLIB::CLIENT-MESSAGE-SEQUENCE-PUT XLIB::CLIENT-MESSAGE-EVENT-PUT-SEQUENCE 
; --> ECASE LET COND IF PROGN XLIB::SEQUENCE-PUT XLIB::WRITE-SEQUENCE-CARD8 MIN 
; --> LET 
; ==>
;   (LENGTH XLIB::DATA)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION BLOCK XLIB::WITH-BUFFER-OUTPUT LET LET* 
; --> XLIB::CLIENT-MESSAGE-SEQUENCE-PUT XLIB::CLIENT-MESSAGE-EVENT-PUT-SEQUENCE 
; --> ECASE LET COND IF IF PROGN XLIB::SEQUENCE-PUT XLIB::WRITE-SEQUENCE-CARD16 
; --> MIN LET 
; ==>
;   (LENGTH XLIB::DATA)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION BLOCK XLIB::WITH-BUFFER-OUTPUT LET LET* 
; --> XLIB::CLIENT-MESSAGE-SEQUENCE-PUT XLIB::CLIENT-MESSAGE-EVENT-PUT-SEQUENCE 
; --> ECASE LET COND IF IF IF PROGN XLIB::SEQUENCE-PUT 
; --> XLIB::WRITE-SEQUENCE-CARD32 MIN LET 
; ==>
;   (LENGTH XLIB::DATA)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DECLARE-EVENT :MAPPING-NOTIFY
;     (XLIB:DECLARE-EVENT :MAPPING-NOTIFY
;       (XLIB:CARD16 SEQUENCE)
;       ((XLIB::MEMBER8 :MODIFIER :KEYBOARD :POINTER) XLIB::REQUEST)
;       (XLIB:CARD8 XLIB::START)
;       (XLIB:CARD8 COUNT))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G42
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :MAPPING-NOTIFY (CARD16 SEQUENCE) ((MEMBER8 :MODIFIER :KEYBOARD :POINTER) REQUEST) (CARD8 START) (CARD8 COUNT))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/input.lisp
; in: DEFUN MAKE-ERROR
;     (FUNCALL XLIB::ERROR-DECODE-FUNCTION XLIB:DISPLAY XLIB::EVENT)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN XLIB::ERROR-DECODE-FUNCTION)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/requests.lisp
; in: DEFUN CREATE-WINDOW
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:WINDOW 'XLIB:WINDOW)
; --> XLIB:WITH-DISPLAY XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN (XLIB:DISPLAY-XID XLIB:DISPLAY))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-CREATEWINDOW+)
;       (XLIB::DATA XLIB::DEPTH)
;       (XLIB:RESOURCE-ID XLIB::WID)
;       (XLIB:WINDOW XLIB::PARENT)
;       (XLIB:INT16 XLIB::X XLIB::Y)
;       (XLIB:CARD16 XLIB::WIDTH XLIB::HEIGHT XLIB::BORDER-WIDTH)
;       ((XLIB::MEMBER16 :COPY :INPUT-OUTPUT :INPUT-ONLY) CLASS)
;       (XLIB:RESOURCE-ID
;        (COND ((EQ XLIB::VISUAL :COPY) 0)
;              ((TYPEP XLIB::VISUAL 'XLIB:RESOURCE-ID) XLIB::VISUAL)
;              (T (XLIB:VISUAL-INFO-ID XLIB::VISUAL))))
;       (XLIB::MASK
;        (XLIB:CARD32 XLIB::BACK-PIXMAP XLIB::BACK-PIXEL XLIB::BORDER-PIXMAP
;         XLIB::BORDER-PIXEL)
;        ((XLIB::MEMBER-VECTOR XLIB::+BIT-GRAVITY-VECTOR+) XLIB:BIT-GRAVITY)
;        ((XLIB::MEMBER-VECTOR XLIB::+WIN-GRAVITY-VECTOR+) XLIB::GRAVITY)
;        ((MEMBER :NOT-USEFUL :WHEN-MAPPED :ALWAYS) XLIB::BACKING-STORE)
;        (XLIB:CARD32 XLIB::BACKING-PLANES XLIB::BACKING-PIXEL)
;        ((MEMBER :OFF :ON) XLIB::OVERRIDE-REDIRECT XLIB::SAVE-UNDER)
;        (XLIB:CARD32 XLIB:EVENT-MASK XLIB::DO-NOT-PROPAGATE-MASK)
;        ((OR (MEMBER :COPY) XLIB:COLORMAP) XLIB:COLORMAP)
;        ((OR (MEMBER :NONE) XLIB:CURSOR) XLIB:CURSOR)))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* LET UNLESS IF PROGN SETQ THE 
; ==>
;   (LOGIOR XLIB::%MASK 2)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 4)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 8)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 16)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 32)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 64)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 128)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 256)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 512)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 1024)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 2048)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 4096)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 8192)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 16384)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/requests.lisp
; in: DEFUN SEND-EVENT
;     (APPLY (SVREF XLIB::*EVENT-SEND-VECTOR* XLIB::INTERNAL-EVENT-CODE)
;            XLIB:DISPLAY XLIB::ARGS)
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN
;    (SVREF XLIB::*EVENT-SEND-VECTOR* XLIB::INTERNAL-EVENT-CODE))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/requests.lisp
; in: DEFUN CREATE-PIXMAP
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:PIXMAP 'XLIB:PIXMAP)
; --> XLIB:WITH-DISPLAY XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN (XLIB:DISPLAY-XID XLIB:DISPLAY))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/requests.lisp
; in: DEFUN CREATE-COLORMAP
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:COLORMAP 'XLIB:COLORMAP)
; --> XLIB:WITH-DISPLAY XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN (XLIB:DISPLAY-XID XLIB:DISPLAY))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/requests.lisp
; in: DEFUN COPY-COLORMAP-AND-FREE
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB::NEW-COLORMAP 'XLIB:COLORMAP)
; --> XLIB:WITH-DISPLAY XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN (XLIB:DISPLAY-XID XLIB:DISPLAY))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/requests.lisp
; in: DEFUN FREE-COLORS
;     (XLIB::WITH-BUFFER-REQUEST ((XLIB:COLORMAP-DISPLAY XLIB:COLORMAP)
;                                 XLIB::+X-FREECOLORS+)
;       (XLIB:COLORMAP XLIB:COLORMAP)
;       (XLIB:CARD32 XLIB::PLANE-MASK)
;       (SEQUENCE XLIB::PIXELS))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::PIXELS)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/requests.lisp
; in: DEFUN QUERY-COLORS
;     (XLIB::WITH-BUFFER-REQUEST-AND-REPLY (XLIB:DISPLAY XLIB::+X-QUERYCOLORS+ NIL
;                                           :SIZES (8 16))
;         ((XLIB:COLORMAP XLIB:COLORMAP) (SEQUENCE XLIB::PIXELS))
;       (LET ((SEQUENCE (MAKE-SEQUENCE XLIB::RESULT-TYPE #)))
;         (XLIB::ADVANCE-BUFFER-OFFSET XLIB::+REPLYSIZE+)
;         (DOTIMES (XLIB::I (LENGTH SEQUENCE) SEQUENCE)
;           (SETF # #)
;           (XLIB::ADVANCE-BUFFER-OFFSET 8))))
; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN XLIB::WITH-BUFFER MACROLET 
; --> LET XLIB::HOLDING-LOCK SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK XLIB::WITHOUT-ABORTS PROGN 
; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET* 
; --> XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::PIXELS)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (LENGTH SEQUENCE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS NULL SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS NULL SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

;     (SETF (ELT SEQUENCE XLIB::I)
;             (XLIB:MAKE-COLOR :RED (XLIB::RGB-VAL-GET 0) :GREEN
;                              (XLIB::RGB-VAL-GET 2) :BLUE (XLIB::RGB-VAL-GET 4)))
; ==>
;   (SB-KERNEL:%SETELT SEQUENCE XLIB::I
;                      (XLIB:MAKE-COLOR :RED (XLIB::RGB-VAL-GET 0) :GREEN
;                                       (XLIB::RGB-VAL-GET 2) :BLUE
;                                       (XLIB::RGB-VAL-GET 4)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS NULL SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS NULL SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/requests.lisp
; in: DEFUN CREATE-CURSOR
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:CURSOR 'XLIB:CURSOR)
; --> XLIB:WITH-DISPLAY XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN (XLIB:DISPLAY-XID XLIB:DISPLAY))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/requests.lisp
; in: DEFUN CREATE-GLYPH-CURSOR
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:CURSOR 'XLIB:CURSOR)
; --> XLIB:WITH-DISPLAY XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN (XLIB:DISPLAY-XID XLIB:DISPLAY))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/requests.lisp
; in: DEFUN CHANGE-KEYBOARD-CONTROL
;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-CHANGEKEYBOARDCONTROL+
;                                 :SIZES (32))
;       (XLIB::MASK
;        (INTEGER XLIB::KEY-CLICK-PERCENT XLIB::BELL-PERCENT XLIB::BELL-PITCH
;         XLIB::BELL-DURATION)
;        (XLIB:CARD32 XLIB::LED) ((MEMBER :OFF :ON) XLIB::LED-MODE)
;        (XLIB:CARD32 XLIB::KEY)
;        ((MEMBER :OFF :ON :DEFAULT) XLIB::AUTO-REPEAT-MODE)))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* LET UNLESS IF PROGN SETQ THE 
; ==>
;   (LOGIOR XLIB::%MASK 2)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 4)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 8)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 16)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 32)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 64)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 128)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/requests.lisp
; in: DEFUN SET-POINTER-MAPPING
;     (LENGTH MAP)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (XLIB::WITH-BUFFER-REQUEST-AND-REPLY (XLIB:DISPLAY
;                                           XLIB::+X-SETPOINTERMAPPING+ 2 :SIZES 8)
;         ((XLIB::DATA (LENGTH MAP)) ((SEQUENCE :FORMAT XLIB:CARD8) MAP))
;       (VALUES (XLIB::BOOLEAN-GET 1)))
; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN XLIB::WITH-BUFFER MACROLET 
; --> LET XLIB::HOLDING-LOCK SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK XLIB::WITHOUT-ABORTS PROGN 
; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET* 
; --> XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH MAP)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/requests.lisp
; in: DEFUN CHANGE-ACCESS-HOST
;     (LENGTH XLIB::ADDRESS)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-CHANGEHOSTS+)
;       ((XLIB::DATA BOOLEAN) XLIB::REMOVE-P)
;       (XLIB:CARD8
;        (XLIB::ENCODE-TYPE (OR NULL (MEMBER :INTERNET :DECNET :CHAOS) XLIB:CARD32)
;                           XLIB::FAMILY))
;       (XLIB:CARD16 (LENGTH XLIB::ADDRESS))
;       ((SEQUENCE :FORMAT XLIB:CARD8) XLIB::ADDRESS))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::ADDRESS)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/requests.lisp
; in: DEFUN ACCESS-HOSTS
;     (SETF (ELT SEQUENCE XLIB::I)
;             (CONS
;              (IF (< XLIB::FAMILY 3)
;                  (SVREF '# XLIB::FAMILY)
;                  XLIB::FAMILY)
;              (XLIB::SEQUENCE-GET :LENGTH XLIB::LEN :FORMAT XLIB:CARD8
;                                  :RESULT-TYPE 'LIST :INDEX
;                                  (+ XLIB::BUFFER-BOFFSET 4))))
; ==>
;   (SB-KERNEL:%SETELT SEQUENCE XLIB::I
;                      (CONS
;                       (IF (< XLIB::FAMILY 3)
;                           (SVREF '#(:INTERNET :DECNET :CHAOS) XLIB::FAMILY)
;                           XLIB::FAMILY)
;                       (XLIB::SEQUENCE-GET :LENGTH XLIB::LEN :FORMAT XLIB:CARD8
;                                           :RESULT-TYPE 'LIST :INDEX
;                                           (+ XLIB::BUFFER-BOFFSET 4))))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS NULL SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS NULL SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/fonts.lisp
; in: DEFUN OPEN-FONT
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:FONT 'XLIB:FONT)
; --> XLIB:WITH-DISPLAY XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN (XLIB:DISPLAY-XID XLIB:DISPLAY))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/fonts.lisp
; in: DEFUN OPEN-FONT-INTERNAL
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:FONT 'XLIB:FONT)
; --> XLIB:WITH-DISPLAY XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN (XLIB:DISPLAY-XID XLIB:DISPLAY))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

;     (LENGTH XLIB::NAME-STRING)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR NULL (VECTOR CHARACTER) (VECTOR NIL) BASE-STRING), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR NULL (VECTOR CHARACTER) (VECTOR NIL) BASE-STRING), not a VECTOR.

;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-OPENFONT+)
;       (XLIB:RESOURCE-ID XLIB::ID)
;       (XLIB:CARD16 (LENGTH XLIB::NAME-STRING))
;       (XLIB::PAD16 NIL)
;       (STRING XLIB::NAME-STRING))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::STRING-PUT LET 
; ==>
;   (LENGTH XLIB::NAME-STRING)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR NULL (VECTOR CHARACTER) (VECTOR NIL) BASE-STRING), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR NULL (VECTOR CHARACTER) (VECTOR NIL) BASE-STRING), not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/fonts.lisp
; in: DEFUN SET-FONT-PATH
;     (CEILING XLIB::REQUEST-LENGTH 4)
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (TRUNCATE NUMBER SB-C::DIVISOR)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to convert division by 2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a REAL, not a (UNSIGNED-BYTE 64).

; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF NOT IF ZEROP 
; ==>
;   (= REM 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (RATIONAL (-4) (4)) DOUBLE-FLOAT SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF PLUSP 
; ==>
;   (> NUMBER 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (ELT XLIB::PATHS XLIB::I)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a LIST.

;     (STRING (ELT XLIB::PATHS XLIB::I))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (VECTOR CHARACTER) (VECTOR NIL) BASE-STRING SYMBOL CHARACTER), not a SYMBOL.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (VECTOR CHARACTER) (VECTOR NIL) BASE-STRING SYMBOL CHARACTER), not a STRING.

;     (CEILING XLIB::REQUEST-LENGTH 4)
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF PLUSP 
; ==>
;   (> NUMBER 0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 
; ==>
;   (+ SB-C::TRU 1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/graphics.lisp
; in: DEFUN DRAW-POINTS
;     (XLIB::WITH-BUFFER-REQUEST ((XLIB:DRAWABLE-DISPLAY XLIB:DRAWABLE)
;                                 XLIB::+X-POLYPOINT+ :GC-FORCE XLIB:GCONTEXT)
;       ((XLIB::DATA BOOLEAN) XLIB::RELATIVE-P)
;       (XLIB:DRAWABLE XLIB:DRAWABLE)
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       ((SEQUENCE :FORMAT XLIB:INT16) XLIB::POINTS))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::POINTS)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/graphics.lisp
; in: DEFUN DRAW-LINES
;     (XLIB::WITH-BUFFER-REQUEST ((XLIB:DRAWABLE-DISPLAY XLIB:DRAWABLE)
;                                 XLIB::+X-POLYLINE+ :GC-FORCE XLIB:GCONTEXT)
;       ((XLIB::DATA BOOLEAN) XLIB::RELATIVE-P)
;       (XLIB:DRAWABLE XLIB:DRAWABLE)
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       ((SEQUENCE :FORMAT XLIB:INT16) XLIB::POINTS))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::POINTS)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/graphics.lisp
; in: DEFUN FILL-POLYGON
;     (XLIB::WITH-BUFFER-REQUEST ((XLIB:DRAWABLE-DISPLAY XLIB:DRAWABLE)
;                                 XLIB::+X-FILLPOLY+ :GC-FORCE XLIB:GCONTEXT)
;       (XLIB:DRAWABLE XLIB:DRAWABLE)
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       ((XLIB::MEMBER8 :COMPLEX :NON-CONVEX :CONVEX) XLIB::SHAPE)
;       (BOOLEAN XLIB::RELATIVE-P)
;       ((SEQUENCE :FORMAT XLIB:INT16) XLIB::POINTS))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::POINTS)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/graphics.lisp
; in: DEFUN DRAW-SEGMENTS
;     (XLIB::WITH-BUFFER-REQUEST ((XLIB:DRAWABLE-DISPLAY XLIB:DRAWABLE)
;                                 XLIB::+X-POLYSEGMENT+ :GC-FORCE XLIB:GCONTEXT)
;       (XLIB:DRAWABLE XLIB:DRAWABLE)
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       ((SEQUENCE :FORMAT XLIB:INT16) XLIB::SEGMENTS))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::SEGMENTS)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/graphics.lisp
; in: DEFUN DRAW-RECTANGLES
;     (XLIB::WITH-BUFFER-REQUEST ((XLIB:DRAWABLE-DISPLAY XLIB:DRAWABLE)
;                                 (IF XLIB::FILL-P
;                                     XLIB::+X-POLYFILLRECTANGLE+
;                                     XLIB::+X-POLYRECTANGLE+)
;                                 :GC-FORCE XLIB:GCONTEXT)
;       (XLIB:DRAWABLE XLIB:DRAWABLE)
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       ((SEQUENCE :FORMAT XLIB:INT16) XLIB::RECTANGLES))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::RECTANGLES)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/graphics.lisp
; in: DEFUN DRAW-ARCS-VECTOR
;     (AREF XLIB::ARCS (XLIB::INDEX+ XLIB::N 0))
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (AREF XLIB::ARCS (XLIB::INDEX+ XLIB::N 1))
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (AREF XLIB::ARCS (XLIB::INDEX+ XLIB::N 2))
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (AREF XLIB::ARCS (XLIB::INDEX+ XLIB::N 3))
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (AREF XLIB::ARCS (XLIB::INDEX+ XLIB::N 4))
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (AREF XLIB::ARCS (XLIB::INDEX+ XLIB::N 5))
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/graphics.lisp
; in: DEFUN PUT-RAW-IMAGE
;     (XLIB::WITH-BUFFER-REQUEST ((XLIB:DRAWABLE-DISPLAY XLIB:DRAWABLE)
;                                 XLIB::+X-PUTIMAGE+ :GC-FORCE XLIB:GCONTEXT)
;       ((XLIB::DATA (MEMBER :BITMAP :XY-PIXMAP :Z-PIXMAP)) FORMAT)
;       (XLIB:DRAWABLE XLIB:DRAWABLE)
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       (XLIB:CARD16 XLIB::WIDTH XLIB::HEIGHT)
;       (XLIB:INT16 XLIB::X XLIB::Y)
;       (XLIB:CARD8 XLIB::LEFT-PAD XLIB::DEPTH)
;       (XLIB::PAD16 NIL)
;       ((SEQUENCE :FORMAT XLIB:CARD8 :START XLIB::START) XLIB::DATA))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::DATA)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/text.lisp
; in: DEFUN TEXT-EXTENTS
;     (LENGTH SEQUENCE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/text.lisp
; in: DEFUN TEXT-WIDTH
;     (LENGTH SEQUENCE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (INCF XLIB::WIDTH
;           (IF (OR (XLIB::FONT-CHAR-INFOS-INTERNAL XLIB:FONT)
;                   (XLIB::FONT-LOCAL-ONLY-P XLIB:FONT))
;               (XLIB::TEXT-EXTENTS-LOCAL XLIB:FONT XLIB::WBUF 0 XLIB::BUF-END
;                :WIDTH-ONLY)
;               (XLIB::TEXT-WIDTH-SERVER XLIB:FONT XLIB::WBUF 0 XLIB::BUF-END)))
; --> SETQ THE 
; ==>
;   (+
;    (IF (OR (XLIB::FONT-CHAR-INFOS-INTERNAL XLIB:FONT)
;            (XLIB::FONT-LOCAL-ONLY-P XLIB:FONT))
;        (XLIB::TEXT-EXTENTS-LOCAL XLIB:FONT XLIB::WBUF 0 XLIB::BUF-END
;         :WIDTH-ONLY)
;        (XLIB::TEXT-WIDTH-SERVER XLIB:FONT XLIB::WBUF 0 XLIB::BUF-END))
;    XLIB::WIDTH)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/text.lisp
; in: DEFUN DRAW-GLYPHS8
;     (DEFUN XLIB::DRAW-GLYPHS8
;            (XLIB:DRAWABLE XLIB:GCONTEXT XLIB::X XLIB::Y SEQUENCE XLIB::START
;             XLIB::END XLIB::TRANSLATE XLIB::WIDTH)
;       (DECLARE (TYPE XLIB:DRAWABLE XLIB:DRAWABLE)
;                (TYPE XLIB:GCONTEXT XLIB:GCONTEXT)
;                (TYPE XLIB:INT16 XLIB::X XLIB::Y)
;                (TYPE XLIB:ARRAY-INDEX XLIB::START)
;                (TYPE SEQUENCE SEQUENCE)
;                (TYPE (OR NULL XLIB:ARRAY-INDEX) XLIB::END)
;                (TYPE (OR NULL XLIB:INT32) XLIB::WIDTH))
;       (DECLARE
;        (XLIB::CLX-VALUES (OR NULL XLIB:ARRAY-INDEX) (OR NULL XLIB:INT32)))
;       (DECLARE (TYPE XLIB:TRANSLATION-FUNCTION XLIB::TRANSLATE)
;                (DYNAMIC-EXTENT XLIB::TRANSLATE))
;       (LET* ((XLIB::SRC-START XLIB::START)
;              (XLIB::SRC-END (OR XLIB::END #))
;              (XLIB::NEXT-START NIL)
;              (LENGTH (XLIB::INDEX- XLIB::SRC-END XLIB::SRC-START))
;              (XLIB::REQUEST-LENGTH (* LENGTH 2))
;              (XLIB:DISPLAY (XLIB:GCONTEXT-DISPLAY XLIB:GCONTEXT))
;              (XLIB:FONT (XLIB:GCONTEXT-FONT XLIB:GCONTEXT NIL)))
;         (DECLARE (TYPE XLIB:ARRAY-INDEX XLIB::SRC-START XLIB::SRC-END LENGTH)
;                  (TYPE (OR NULL XLIB:ARRAY-INDEX) XLIB::NEXT-START)
;                  (TYPE XLIB:DISPLAY XLIB:DISPLAY))
;         (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-POLYTEXT8+ :GC-FORCE
;                                     XLIB:GCONTEXT :LENGTH XLIB::REQUEST-LENGTH)
;           (XLIB:DRAWABLE XLIB:DRAWABLE)
;           (XLIB:GCONTEXT XLIB:GCONTEXT)
;           (XLIB:INT16 XLIB::X XLIB::Y)
;           (PROGN
;            (XLIB::WITH-BUFFER-FLUSH-INHIBITED #
;              #)))
;         (VALUES XLIB::NEXT-START XLIB::WIDTH)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G122
; 
; note: could not stack allocate TRANSLATE in: (DEFUN DRAW-GLYPHS8 (DRAWABLE GCONTEXT X Y SEQUENCE START END TRANSLATE WIDTH) (DECLARE (TYPE DRAWABLE DRAWABLE) (TYPE GCONTEXT GCONTEXT) (TYPE INT16 X Y) (TYPE ARRAY-INDEX START) (TYPE SEQUENCE SEQUENCE) (TYPE (OR NULL ARRAY-INDEX) END) (TYPE (OR NULL INT32) WIDTH)) (DECLARE (CLX-VALUES (OR NULL ARRAY-INDEX) (OR NULL INT32))) (DECLARE (TYPE TRANSLATION-FUNCTION TRANSLATE) (DYNAMIC-EXTENT TRANSLATE)) (LET* ((SRC-START START) (SRC-END (OR END (LENGTH SEQUENCE))) (NEXT-START NIL) (LENGTH (INDEX- SRC-END SRC-START)) (REQUEST-LENGTH (* LENGTH 2)) (DISPLAY (GCONTEXT-DISPLAY GCONTEXT)) (FONT (GCONTEXT-FONT GCONTEXT NIL))) (DECLARE (TYPE ARRAY-INDEX SRC-START SRC-END LENGTH) (TYPE (OR NULL ARRAY-INDEX) NEXT-START) (TYPE DISPLAY DISPLAY)) (WITH-BUFFER-REQUEST (DISPLAY +X-POLYTEXT8+ :GC-FORCE GCONTEXT :LENGTH REQUEST-LENGTH) (DRAWABLE DRAWABLE) (GCONTEXT GCONTEXT) (INT16 X Y) (PROGN (WITH-BUFFER-FLUSH-INHIBITED (DISPLAY) (DO* ((BOFFSET (INDEX+ BUFFER-BOFFSET 16)) (SRC-CHUNK 0) (DST-CHUNK 0) (OFFSET 0) (OVERALL-WIDTH 0) (STOP-P NIL)) ((OR STOP-P (ZEROP LENGTH)) (DO ((END (THE ARRAY-INDEX (LROUND BOFFSET)))) ((INDEX>= BOFFSET END)) (SETF (AREF BUFFER-BBUF BOFFSET) 0) (INDEX-INCF BOFFSET)) (LENGTH-PUT 2 (INDEX-ASH (INDEX- BOFFSET BUFFER-BOFFSET) -2)) (SETF (BUFFER-BOFFSET DISPLAY) BOFFSET) (UNLESS (INDEX-ZEROP LENGTH) (SETQ NEXT-START SRC-START)) (WHEN OVERALL-WIDTH (SETQ WIDTH OVERALL-WIDTH))) (DECLARE (TYPE ARRAY-INDEX SRC-CHUNK DST-CHUNK OFFSET) (TYPE (OR NULL INT32) OVERALL-WIDTH) (TYPE GENERALIZED-BOOLEAN STOP-P)) (SETQ SRC-CHUNK (INDEX-MIN LENGTH *MAX-STRING-SIZE*)) (MULTIPLE-VALUE-BIND (NEW-START NEW-FONT TRANSLATED-WIDTH) (FUNCALL TRANSLATE SEQUENCE SRC-START (INDEX+ SRC-START SRC-CHUNK) FONT BUFFER-BBUF (INDEX+ BOFFSET 2)) (SETQ DST-CHUNK (INDEX- NEW-START SRC-START) LENGTH (INDEX- LENGTH DST-CHUNK) SRC-START NEW-START) (IF TRANSLATED-WIDTH (WHEN OVERALL-WIDTH (INCF OVERALL-WIDTH TRANSLATED-WIDTH)) (SETQ OVERALL-WIDTH NIL)) (WHEN (INDEX-PLUSP DST-CHUNK) (SETF (AREF BUFFER-BBUF BOFFSET) DST-CHUNK) (SETF (AREF BUFFER-BBUF (INDEX+ BOFFSET 1)) OFFSET) (INCF BOFFSET (INDEX+ DST-CHUNK 2))) (SETQ OFFSET 0) (COND ((NULL NEW-FONT) (UNLESS (INDEX= SRC-CHUNK DST-CHUNK) (SETQ STOP-P T))) ((INTEGERP NEW-FONT) (SETQ OFFSET NEW-FONT)) ((TYPE? NEW-FONT (QUOTE FONT)) (SETQ FONT NEW-FONT) (LET ((FONT-ID (FONT-ID FONT)) (BUFFER-BOFFSET BOFFSET)) (DECLARE (TYPE RESOURCE-ID FONT-ID) (TYPE ARRAY-INDEX BUFFER-BOFFSET)) (LET ((LOCAL-STATE (GCONTEXT-LOCAL-STATE GCONTEXT)) (SERVER-STATE (GCONTEXT-SERVER-STATE GCONTEXT))) (DECLARE (TYPE GCONTEXT-STATE LOCAL-STATE SERVER-STATE)) (SETF (GCONTEXT-INTERNAL-FONT-OBJ SERVER-STATE) FONT (GCONTEXT-INTERNAL-FONT SERVER-STATE) FONT-ID) (WITHOUT-INTERRUPTS (SETF (GCONTEXT-INTERNAL-FONT-OBJ LOCAL-STATE) FONT (GCONTEXT-INTERNAL-FONT LOCAL-STATE) FONT-ID))) (CARD8-PUT 0 255) (CARD8-PUT 1 (LDB (BYTE 8 24) FONT-ID)) (CARD8-PUT 2 (LDB (BYTE 8 16) FONT-ID)) (CARD8-PUT 3 (LDB (BYTE 8 8) FONT-ID)) (CARD8-PUT 4 (LDB (BYTE 8 0) FONT-ID))) (INDEX-INCF BOFFSET 5)))))))) (VALUES NEXT-START WIDTH)))

;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-POLYTEXT8+ :GC-FORCE
;                                 XLIB:GCONTEXT :LENGTH XLIB::REQUEST-LENGTH)
;       (XLIB:DRAWABLE XLIB:DRAWABLE)
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       (XLIB:INT16 XLIB::X XLIB::Y)
;       (PROGN
;        (XLIB::WITH-BUFFER-FLUSH-INHIBITED (XLIB:DISPLAY)
;          (DO* (#
;                #
;                #
;                #
;                #
;                #)
;               (# # # # # #)
;            (DECLARE #
;                     #
;                     #)
;            (SETQ #)
;            (MULTIPLE-VALUE-BIND # # # # # # #)))))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-C::%%ALLOCATE-CLOSURES 
; ==>
;   (SB-C::%ALLOCATE-CLOSURES
;    '(#'(FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN XLIB::DRAW-GLYPHS8)))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of CLOSURE-INIT

;     (INCF XLIB::BOFFSET (XLIB::INDEX+ XLIB::DST-CHUNK 2))
; ==>
;   (SETQ XLIB::BOFFSET (+ (XLIB::INDEX+ XLIB::DST-CHUNK 2) XLIB::BOFFSET))
; 
; note: doing signed word to integer coercion (cost 20) to BOFFSET

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/text.lisp
; in: DEFUN DRAW-GLYPHS16
;     (DEFUN XLIB::DRAW-GLYPHS16
;            (XLIB:DRAWABLE XLIB:GCONTEXT XLIB::X XLIB::Y SEQUENCE XLIB::START
;             XLIB::END XLIB::TRANSLATE XLIB::WIDTH)
;       (DECLARE (TYPE XLIB:DRAWABLE XLIB:DRAWABLE)
;                (TYPE XLIB:GCONTEXT XLIB:GCONTEXT)
;                (TYPE XLIB:INT16 XLIB::X XLIB::Y)
;                (TYPE XLIB:ARRAY-INDEX XLIB::START)
;                (TYPE SEQUENCE SEQUENCE)
;                (TYPE (OR NULL XLIB:ARRAY-INDEX) XLIB::END)
;                (TYPE (OR NULL XLIB:INT32) XLIB::WIDTH))
;       (DECLARE
;        (XLIB::CLX-VALUES (OR NULL XLIB:ARRAY-INDEX) (OR NULL XLIB:INT32)))
;       (DECLARE (TYPE XLIB:TRANSLATION-FUNCTION XLIB::TRANSLATE)
;                (DYNAMIC-EXTENT XLIB::TRANSLATE))
;       (LET* ((XLIB::SRC-START XLIB::START)
;              (XLIB::SRC-END (OR XLIB::END #))
;              (XLIB::NEXT-START NIL)
;              (LENGTH (XLIB::INDEX- XLIB::SRC-END XLIB::SRC-START))
;              (XLIB::REQUEST-LENGTH (* LENGTH 3))
;              (XLIB:DISPLAY (XLIB:GCONTEXT-DISPLAY XLIB:GCONTEXT))
;              (XLIB:FONT (XLIB:GCONTEXT-FONT XLIB:GCONTEXT NIL))
;              (XLIB::BUFFER (XLIB::DISPLAY-TBUF16 XLIB:DISPLAY)))
;         (DECLARE (TYPE XLIB:ARRAY-INDEX XLIB::SRC-START XLIB::SRC-END LENGTH)
;                  (TYPE (OR NULL XLIB:ARRAY-INDEX) XLIB::NEXT-START)
;                  (TYPE XLIB:DISPLAY XLIB:DISPLAY)
;                  (TYPE XLIB::BUFFER-TEXT16 XLIB::BUFFER))
;         (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-POLYTEXT16+ :GC-FORCE
;                                     XLIB:GCONTEXT :LENGTH XLIB::REQUEST-LENGTH)
;           (XLIB:DRAWABLE XLIB:DRAWABLE)
;           (XLIB:GCONTEXT XLIB:GCONTEXT)
;           (XLIB:INT16 XLIB::X XLIB::Y)
;           (PROGN
;            (XLIB::WITH-BUFFER-FLUSH-INHIBITED #
;              #)))
;         (VALUES XLIB::NEXT-START XLIB::WIDTH)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G129
; 
; note: could not stack allocate TRANSLATE in: (DEFUN DRAW-GLYPHS16 (DRAWABLE GCONTEXT X Y SEQUENCE START END TRANSLATE WIDTH) (DECLARE (TYPE DRAWABLE DRAWABLE) (TYPE GCONTEXT GCONTEXT) (TYPE INT16 X Y) (TYPE ARRAY-INDEX START) (TYPE SEQUENCE SEQUENCE) (TYPE (OR NULL ARRAY-INDEX) END) (TYPE (OR NULL INT32) WIDTH)) (DECLARE (CLX-VALUES (OR NULL ARRAY-INDEX) (OR NULL INT32))) (DECLARE (TYPE TRANSLATION-FUNCTION TRANSLATE) (DYNAMIC-EXTENT TRANSLATE)) (LET* ((SRC-START START) (SRC-END (OR END (LENGTH SEQUENCE))) (NEXT-START NIL) (LENGTH (INDEX- SRC-END SRC-START)) (REQUEST-LENGTH (* LENGTH 3)) (DISPLAY (GCONTEXT-DISPLAY GCONTEXT)) (FONT (GCONTEXT-FONT GCONTEXT NIL)) (BUFFER (DISPLAY-TBUF16 DISPLAY))) (DECLARE (TYPE ARRAY-INDEX SRC-START SRC-END LENGTH) (TYPE (OR NULL ARRAY-INDEX) NEXT-START) (TYPE DISPLAY DISPLAY) (TYPE BUFFER-TEXT16 BUFFER)) (WITH-BUFFER-REQUEST (DISPLAY +X-POLYTEXT16+ :GC-FORCE GCONTEXT :LENGTH REQUEST-LENGTH) (DRAWABLE DRAWABLE) (GCONTEXT GCONTEXT) (INT16 X Y) (PROGN (WITH-BUFFER-FLUSH-INHIBITED (DISPLAY) (DO* ((BOFFSET (INDEX+ BUFFER-BOFFSET 16)) (SRC-CHUNK 0) (DST-CHUNK 0) (OFFSET 0) (OVERALL-WIDTH 0) (STOP-P NIL)) ((OR STOP-P (ZEROP LENGTH)) (DO ((END (LROUND BOFFSET))) ((INDEX>= BOFFSET END)) (SETF (AREF BUFFER-BBUF BOFFSET) 0) (INDEX-INCF BOFFSET)) (LENGTH-PUT 2 (INDEX-ASH (INDEX- BOFFSET BUFFER-BOFFSET) -2)) (SETF (BUFFER-BOFFSET DISPLAY) BOFFSET) (UNLESS (ZEROP LENGTH) (SETQ NEXT-START SRC-START)) (WHEN OVERALL-WIDTH (SETQ WIDTH OVERALL-WIDTH))) (DECLARE (TYPE ARRAY-INDEX BOFFSET SRC-CHUNK DST-CHUNK OFFSET) (TYPE (OR NULL INT32) OVERALL-WIDTH) (TYPE GENERALIZED-BOOLEAN STOP-P)) (SETQ SRC-CHUNK (INDEX-MIN LENGTH *MAX-STRING-SIZE*)) (MULTIPLE-VALUE-BIND (NEW-START NEW-FONT TRANSLATED-WIDTH) (FUNCALL TRANSLATE SEQUENCE SRC-START (INDEX+ SRC-START SRC-CHUNK) FONT BUFFER 0) (SETQ DST-CHUNK (INDEX- NEW-START SRC-START) LENGTH (INDEX- LENGTH DST-CHUNK) SRC-START NEW-START) (WRITE-SEQUENCE-CHAR2B DISPLAY (INDEX+ BOFFSET 2) BUFFER 0 DST-CHUNK) (IF TRANSLATED-WIDTH (WHEN OVERALL-WIDTH (INCF OVERALL-WIDTH TRANSLATED-WIDTH)) (SETQ OVERALL-WIDTH NIL)) (WHEN (INDEX-PLUSP DST-CHUNK) (SETF (AREF BUFFER-BBUF BOFFSET) DST-CHUNK) (SETF (AREF BUFFER-BBUF (INDEX+ BOFFSET 1)) OFFSET) (INDEX-INCF BOFFSET (INDEX+ DST-CHUNK DST-CHUNK 2))) (SETQ OFFSET 0) (COND ((NULL NEW-FONT) (UNLESS (INDEX= SRC-CHUNK DST-CHUNK) (SETQ STOP-P T))) ((INTEGERP NEW-FONT) (SETQ OFFSET NEW-FONT)) ((TYPE? NEW-FONT (QUOTE FONT)) (SETQ FONT NEW-FONT) (LET ((FONT-ID (FONT-ID FONT)) (BUFFER-BOFFSET BOFFSET)) (DECLARE (TYPE RESOURCE-ID FONT-ID) (TYPE ARRAY-INDEX BUFFER-BOFFSET)) (LET ((LOCAL-STATE (GCONTEXT-LOCAL-STATE GCONTEXT)) (SERVER-STATE (GCONTEXT-SERVER-STATE GCONTEXT))) (DECLARE (TYPE GCONTEXT-STATE LOCAL-STATE SERVER-STATE)) (SETF (GCONTEXT-INTERNAL-FONT-OBJ SERVER-STATE) FONT (GCONTEXT-INTERNAL-FONT SERVER-STATE) FONT-ID) (WITHOUT-INTERRUPTS (SETF (GCONTEXT-INTERNAL-FONT-OBJ LOCAL-STATE) FONT (GCONTEXT-INTERNAL-FONT LOCAL-STATE) FONT-ID))) (CARD8-PUT 0 255) (CARD8-PUT 1 (LDB (BYTE 8 24) FONT-ID)) (CARD8-PUT 2 (LDB (BYTE 8 16) FONT-ID)) (CARD8-PUT 3 (LDB (BYTE 8 8) FONT-ID)) (CARD8-PUT 4 (LDB (BYTE 8 0) FONT-ID))) (INDEX-INCF BOFFSET 5)))))))) (VALUES NEXT-START WIDTH)))

;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-POLYTEXT16+ :GC-FORCE
;                                 XLIB:GCONTEXT :LENGTH XLIB::REQUEST-LENGTH)
;       (XLIB:DRAWABLE XLIB:DRAWABLE)
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       (XLIB:INT16 XLIB::X XLIB::Y)
;       (PROGN
;        (XLIB::WITH-BUFFER-FLUSH-INHIBITED (XLIB:DISPLAY)
;          (DO* (#
;                #
;                #
;                #
;                #
;                #)
;               (# # # # # #)
;            (DECLARE #
;                     #
;                     #)
;            (SETQ #)
;            (MULTIPLE-VALUE-BIND # # # # # # # #)))))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-C::%%ALLOCATE-CLOSURES 
; ==>
;   (SB-C::%ALLOCATE-CLOSURES
;    '(#'(FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN XLIB::DRAW-GLYPHS16)))
; 
; note: doing unsigned word to integer coercion (cost 20), for:
;       the second argument of CLOSURE-INIT

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/text.lisp
; in: DEFUN DRAW-IMAGE-GLYPHS8
;     (DEFUN XLIB::DRAW-IMAGE-GLYPHS8
;            (XLIB:DRAWABLE XLIB:GCONTEXT XLIB::X XLIB::Y SEQUENCE XLIB::START
;             XLIB::END XLIB::TRANSLATE XLIB::WIDTH)
;       (DECLARE (TYPE XLIB:DRAWABLE XLIB:DRAWABLE)
;                (TYPE XLIB:GCONTEXT XLIB:GCONTEXT)
;                (TYPE XLIB:INT16 XLIB::X XLIB::Y)
;                (TYPE XLIB:ARRAY-INDEX XLIB::START)
;                (TYPE SEQUENCE SEQUENCE)
;                (TYPE (OR NULL XLIB:ARRAY-INDEX) XLIB::END)
;                (TYPE (OR NULL XLIB:INT32) XLIB::WIDTH))
;       (DECLARE (TYPE (OR NULL XLIB:TRANSLATION-FUNCTION) XLIB::TRANSLATE)
;                (DYNAMIC-EXTENT XLIB::TRANSLATE))
;       (DECLARE
;        (XLIB::CLX-VALUES (OR NULL XLIB:ARRAY-INDEX) (OR NULL XLIB:INT32)))
;       (DO* ((XLIB:DISPLAY (XLIB:GCONTEXT-DISPLAY XLIB:GCONTEXT))
;             (LENGTH (XLIB::INDEX- XLIB::END XLIB::START))
;             (XLIB:FONT (XLIB:GCONTEXT-FONT XLIB:GCONTEXT NIL))
;             (XLIB::FONT-CHANGE NIL)
;             (XLIB::NEW-START)
;             (XLIB::TRANSLATED-WIDTH)
;             (XLIB::CHUNK))
;            (NIL)
;         (DECLARE (TYPE XLIB:DISPLAY XLIB:DISPLAY)
;                  (TYPE XLIB:ARRAY-INDEX LENGTH)
;                  (TYPE (OR NULL XLIB:ARRAY-INDEX) XLIB::NEW-START XLIB::CHUNK))
;         (WHEN XLIB::FONT-CHANGE (SETF # XLIB:FONT))
;         (BLOCK XLIB::CHANGE-FONT
;           (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-IMAGETEXT8+ :GC-FORCE
;                                       XLIB:GCONTEXT :LENGTH LENGTH)
;             (XLIB:DRAWABLE XLIB:DRAWABLE)
;             (XLIB:GCONTEXT XLIB:GCONTEXT)
;             (XLIB:INT16 XLIB::X XLIB::Y)
;             (PROGN #))
;           (RETURN-FROM XLIB::DRAW-IMAGE-GLYPHS8 (VALUES # #)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G81
; 
; note: could not stack allocate TRANSLATE in: (DEFUN DRAW-IMAGE-GLYPHS8 (DRAWABLE GCONTEXT X Y SEQUENCE START END TRANSLATE WIDTH) (DECLARE (TYPE DRAWABLE DRAWABLE) (TYPE GCONTEXT GCONTEXT) (TYPE INT16 X Y) (TYPE ARRAY-INDEX START) (TYPE SEQUENCE SEQUENCE) (TYPE (OR NULL ARRAY-INDEX) END) (TYPE (OR NULL INT32) WIDTH)) (DECLARE (TYPE (OR NULL TRANSLATION-FUNCTION) TRANSLATE) (DYNAMIC-EXTENT TRANSLATE)) (DECLARE (CLX-VALUES (OR NULL ARRAY-INDEX) (OR NULL INT32))) (DO* ((DISPLAY (GCONTEXT-DISPLAY GCONTEXT)) (LENGTH (INDEX- END START)) (FONT (GCONTEXT-FONT GCONTEXT NIL)) (FONT-CHANGE NIL) (NEW-START) (TRANSLATED-WIDTH) (CHUNK)) (NIL) (DECLARE (TYPE DISPLAY DISPLAY) (TYPE ARRAY-INDEX LENGTH) (TYPE (OR NULL ARRAY-INDEX) NEW-START CHUNK)) (WHEN FONT-CHANGE (SETF (GCONTEXT-FONT GCONTEXT) FONT)) (BLOCK CHANGE-FONT (WITH-BUFFER-REQUEST (DISPLAY +X-IMAGETEXT8+ :GC-FORCE GCONTEXT :LENGTH LENGTH) (DRAWABLE DRAWABLE) (GCONTEXT GCONTEXT) (INT16 X Y) (PROGN (WITH-BUFFER-FLUSH-INHIBITED (DISPLAY) (MULTIPLE-VALUE-SETQ (NEW-START FONT TRANSLATED-WIDTH) (FUNCALL (OR TRANSLATE (FUNCTION TRANSLATE-DEFAULT)) SEQUENCE START END FONT BUFFER-BBUF (INDEX+ BUFFER-BOFFSET 16))) (SETQ CHUNK (INDEX- NEW-START START)) (WHEN (AND (INDEX-ZEROP CHUNK) (TYPE? FONT (QUOTE FONT))) (SETQ FONT-CHANGE T) (RETURN-FROM CHANGE-FONT)) (WHEN (INDEX-ZEROP CHUNK) (RETURN-FROM DRAW-IMAGE-GLYPHS8 NEW-START)) (DATA-PUT 1 CHUNK) (LET ((BLEN (LROUND (INDEX+ 16 CHUNK)))) (LENGTH-PUT 2 (INDEX-ASH BLEN -2)) (SETF (BUFFER-BOFFSET DISPLAY) (INDEX+ BUFFER-BOFFSET BLEN)))))) (RETURN-FROM DRAW-IMAGE-GLYPHS8 (VALUES (IF (INDEX= CHUNK LENGTH) NIL NEW-START) (OR TRANSLATED-WIDTH WIDTH))))))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/text.lisp
; in: DEFUN DRAW-IMAGE-GLYPHS16
;     (DEFUN XLIB::DRAW-IMAGE-GLYPHS16
;            (XLIB:DRAWABLE XLIB:GCONTEXT XLIB::X XLIB::Y SEQUENCE XLIB::START
;             XLIB::END XLIB::TRANSLATE XLIB::WIDTH)
;       (DECLARE (TYPE XLIB:DRAWABLE XLIB:DRAWABLE)
;                (TYPE XLIB:GCONTEXT XLIB:GCONTEXT)
;                (TYPE XLIB:INT16 XLIB::X XLIB::Y)
;                (TYPE XLIB:ARRAY-INDEX XLIB::START)
;                (TYPE SEQUENCE SEQUENCE)
;                (TYPE (OR NULL XLIB:ARRAY-INDEX) XLIB::END)
;                (TYPE (OR NULL XLIB:INT32) XLIB::WIDTH))
;       (DECLARE (TYPE (OR NULL XLIB:TRANSLATION-FUNCTION) XLIB::TRANSLATE)
;                (DYNAMIC-EXTENT XLIB::TRANSLATE))
;       (DECLARE
;        (XLIB::CLX-VALUES (OR NULL XLIB:ARRAY-INDEX) (OR NULL XLIB:INT32)))
;       (DO* ((XLIB:DISPLAY (XLIB:GCONTEXT-DISPLAY XLIB:GCONTEXT))
;             (LENGTH (XLIB::INDEX- XLIB::END XLIB::START))
;             (XLIB:FONT (XLIB:GCONTEXT-FONT XLIB:GCONTEXT NIL))
;             (XLIB::FONT-CHANGE NIL)
;             (XLIB::NEW-START)
;             (XLIB::TRANSLATED-WIDTH)
;             (XLIB::CHUNK)
;             (XLIB::BUFFER (XLIB::BUFFER-TBUF16 XLIB:DISPLAY)))
;            (NIL)
;         (DECLARE (TYPE XLIB:DISPLAY XLIB:DISPLAY)
;                  (TYPE XLIB:ARRAY-INDEX LENGTH)
;                  (TYPE (OR NULL XLIB:ARRAY-INDEX) XLIB::NEW-START XLIB::CHUNK)
;                  (TYPE XLIB::BUFFER-TEXT16 XLIB::BUFFER))
;         (WHEN XLIB::FONT-CHANGE (SETF # XLIB:FONT))
;         (BLOCK XLIB::CHANGE-FONT
;           (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-IMAGETEXT16+
;                                       :GC-FORCE XLIB:GCONTEXT :LENGTH LENGTH)
;             (XLIB:DRAWABLE XLIB:DRAWABLE)
;             (XLIB:GCONTEXT XLIB:GCONTEXT)
;             (XLIB:INT16 XLIB::X XLIB::Y)
;             (PROGN #))
;           (RETURN-FROM XLIB::DRAW-IMAGE-GLYPHS16 (VALUES # #)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G86
; 
; note: could not stack allocate TRANSLATE in: (DEFUN DRAW-IMAGE-GLYPHS16 (DRAWABLE GCONTEXT X Y SEQUENCE START END TRANSLATE WIDTH) (DECLARE (TYPE DRAWABLE DRAWABLE) (TYPE GCONTEXT GCONTEXT) (TYPE INT16 X Y) (TYPE ARRAY-INDEX START) (TYPE SEQUENCE SEQUENCE) (TYPE (OR NULL ARRAY-INDEX) END) (TYPE (OR NULL INT32) WIDTH)) (DECLARE (TYPE (OR NULL TRANSLATION-FUNCTION) TRANSLATE) (DYNAMIC-EXTENT TRANSLATE)) (DECLARE (CLX-VALUES (OR NULL ARRAY-INDEX) (OR NULL INT32))) (DO* ((DISPLAY (GCONTEXT-DISPLAY GCONTEXT)) (LENGTH (INDEX- END START)) (FONT (GCONTEXT-FONT GCONTEXT NIL)) (FONT-CHANGE NIL) (NEW-START) (TRANSLATED-WIDTH) (CHUNK) (BUFFER (BUFFER-TBUF16 DISPLAY))) (NIL) (DECLARE (TYPE DISPLAY DISPLAY) (TYPE ARRAY-INDEX LENGTH) (TYPE (OR NULL ARRAY-INDEX) NEW-START CHUNK) (TYPE BUFFER-TEXT16 BUFFER)) (WHEN FONT-CHANGE (SETF (GCONTEXT-FONT GCONTEXT) FONT)) (BLOCK CHANGE-FONT (WITH-BUFFER-REQUEST (DISPLAY +X-IMAGETEXT16+ :GC-FORCE GCONTEXT :LENGTH LENGTH) (DRAWABLE DRAWABLE) (GCONTEXT GCONTEXT) (INT16 X Y) (PROGN (WITH-BUFFER-FLUSH-INHIBITED (DISPLAY) (MULTIPLE-VALUE-SETQ (NEW-START FONT TRANSLATED-WIDTH) (FUNCALL (OR TRANSLATE (FUNCTION TRANSLATE-DEFAULT)) SEQUENCE START END FONT BUFFER 0)) (SETQ CHUNK (INDEX- NEW-START START)) (WHEN (AND (INDEX-ZEROP CHUNK) (TYPE? FONT (QUOTE FONT))) (SETQ FONT-CHANGE T) (RETURN-FROM CHANGE-FONT)) (WHEN (INDEX-ZEROP CHUNK) (RETURN-FROM DRAW-IMAGE-GLYPHS16 NEW-START)) (WRITE-SEQUENCE-CHAR2B DISPLAY (INDEX+ BUFFER-BOFFSET 16) BUFFER 0 CHUNK) (DATA-PUT 1 CHUNK) (LET ((BLEN (LROUND (INDEX+ 16 (INDEX-ASH CHUNK 1))))) (LENGTH-PUT 2 (INDEX-ASH BLEN -2)) (SETF (BUFFER-BOFFSET DISPLAY) (INDEX+ BUFFER-BOFFSET BLEN)))))) (RETURN-FROM DRAW-IMAGE-GLYPHS16 (VALUES (IF (INDEX= CHUNK LENGTH) NIL NEW-START) (OR TRANSLATED-WIDTH WIDTH))))))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/text.lisp
; in: DEFUN CHANGE-KEYBOARD-MAPPING
;     (AREF XLIB::KEYSYMS XLIB::I XLIB::J)
; --> LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/text.lisp
; in: DEFUN KEYBOARD-MAPPING
;     (1+ XLIB::I)
; ==>
;   (+ XLIB::I 1)
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (SETF (AREF XLIB::RESULT XLIB::I XLIB::J) (XLIB::CARD29-GET (* XLIB::J 4)))
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE)
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.

;     (1+ XLIB::I)
; ==>
;   (+ XLIB::I 1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/attributes.lisp
; in: DEFUN CHANGE-WINDOW-ATTRIBUTE
;     (ASH 1 NUMBER)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/attributes.lisp
; in: DEFUN CHANGE-DRAWABLE-GEOMETRY
;     (ASH 1 NUMBER)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/image.lisp
; in: DEFUN GET-IMAGE
;     (FIND XLIB::DEPTH (XLIB:DISPLAY-PIXMAP-FORMATS XLIB:DISPLAY) :KEY
;           #'XLIB:PIXMAP-FORMAT-DEPTH)
; 
; note: unable to optimize due to type uncertainty: The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/image.lisp
; in: DEFUN COPY-PIXARRAY
;     (MAKE-ARRAY (LIST XLIB::HEIGHT XLIB::PADDED-WIDTH) :ELEMENT-TYPE
;                 (ARRAY-ELEMENT-TYPE ARRAY))
; --> LET* TRULY-THE SB-C::MAKE-ARRAY-HEADER* 
; ==>
;   (MAKE-ARRAY #:SIZE :ELEMENT-TYPE (ARRAY-ELEMENT-TYPE ARRAY))
; 
; note: unable to optimize because: ELEMENT-TYPE is not constant.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/resource.lisp
; in: DEFUN DELETE-RESOURCE-INTERNAL
;     (SETQ XLIB::LOOSE-P NIL)
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/resource.lisp
; in: DEFUN MAP-RESOURCE
;     (XLIB::MAP-RESOURCE-INTERNAL XLIB::RESOURCE FUNCTION XLIB::ARGS XLIB::NAME)
; ==>
;   FUNCTION
; 
; note: could not stack allocate FUNCTION in: (MAP-RESOURCE-INTERNAL RESOURCE FUNCTION ARGS NAME)
; 
; note: could not stack allocate FUNCTION in: (MAP-RESOURCE-INTERNAL RESOURCE FUNCTION ARGS NAME)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/shape.lisp
; in: DECLARE-EVENT :SHAPE-NOTIFY
;     (XLIB:DECLARE-EVENT :SHAPE-NOTIFY
;       ((XLIB::DATA (XLIB::MEMBER8 :BOUNDING :CLIP)) XLIB::KIND)
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW))
;       (XLIB:INT16 XLIB::X)
;       (XLIB:INT16 XLIB::Y)
;       (XLIB:CARD16 XLIB::WIDTH)
;       (XLIB:CARD16 XLIB::HEIGHT)
;       ((OR NULL XLIB:CARD32) TIME)
;       (BOOLEAN XLIB::SHAPED-P))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G52
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :SHAPE-NOTIFY ((DATA (MEMBER8 :BOUNDING :CLIP)) KIND) (CARD16 SEQUENCE) (WINDOW (WINDOW EVENT-WINDOW)) (INT16 X) (INT16 Y) (CARD16 WIDTH) (CARD16 HEIGHT) ((OR NULL CARD32) TIME) (BOOLEAN SHAPED-P))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/shape.lisp
; in: DEFUN SHAPE-RECTANGLES
;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY
;                                 (XLIB:EXTENSION-OPCODE XLIB:DISPLAY "SHAPE"))
;       (XLIB::DATA 1)
;       (XLIB:CARD8 (XLIB::ENCODE-SHAPE-OPERATION XLIB::OPERATION))
;       (XLIB:CARD8 (XLIB::ENCODE-SHAPE-KIND XLIB::KIND))
;       (XLIB:CARD8 (XLIB::ENCODE-SHAPE-RECTANGLE-ORDERING XLIB::ORDERING))
;       (XLIB:CARD8 0)
;       (XLIB:WINDOW XLIB:WINDOW)
;       (XLIB:INT16 XLIB::X-OFFSET)
;       (XLIB:INT16 XLIB::Y-OFFSET)
;       ((SEQUENCE :FORMAT XLIB:INT16) XLIB::RECTANGLES))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::RECTANGLES)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/xvidmode.lisp
; in: DECLARE-EVENT :XFREE86-VIDMODE-NOTIFY
;     (XLIB:DECLARE-EVENT :XFREE86-VIDMODE-NOTIFY
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW))
;       (XLIB:INT16 XLIB::STATE)
;       (XLIB:INT16 XLIB::KIND)
;       (BOOLEAN XLIB::FORCED-P)
;       ((OR NULL XLIB:CARD32) TIME))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G46
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :XFREE86-VIDMODE-NOTIFY (CARD16 SEQUENCE) (WINDOW (WINDOW EVENT-WINDOW)) (INT16 STATE) (INT16 KIND) (BOOLEAN FORCED-P) ((OR NULL CARD32) TIME))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/xvidmode.lisp
; in: DEFUN XFREE86-VIDMODE-GET-GAMMA
;     (/ (THE XLIB:CARD32 (OR (XLIB::CARD32-GET 8) 0)) 10000.0)
; ==>
;   (/ (FLOAT SB-C::X SB-C::Y) SB-C::Y)
; 
; note: unable to convert to multiplication by reciprocal because: 10000.0 does not have an exact reciprocal

;     (/ (THE XLIB:CARD32 (OR (XLIB::CARD32-GET 12) 0)) 10000.0)
; ==>
;   (/ (FLOAT SB-C::X SB-C::Y) SB-C::Y)
; 
; note: unable to convert to multiplication by reciprocal because: 10000.0 does not have an exact reciprocal

;     (/ (THE XLIB:CARD32 (OR (XLIB::CARD32-GET 16) 0)) 10000.0)
; ==>
;   (/ (FLOAT SB-C::X SB-C::Y) SB-C::Y)
; 
; note: unable to convert to multiplication by reciprocal because: 10000.0 does not have an exact reciprocal

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/glx.lisp
; in: DECLARE-EVENT :GLX-PBUFFER-CLOBBER
;     (XLIB:DECLARE-EVENT :GLX-PBUFFER-CLOBBER
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:CARD16 XLIB/GLX::EVENT-TYPE)
;       (XLIB:CARD16 XLIB/GLX::DRAW-TYPE)
;       (XLIB:RESOURCE-ID XLIB:DRAWABLE)
;       (XLIB:CARD32 XLIB/GLX::BUFFER-MASK)
;       (XLIB:CARD16 XLIB/GLX::AUX-BUFFER)
;       (XLIB:CARD16 XLIB/GLX::X XLIB/GLX::Y XLIB/GLX::WIDTH XLIB/GLX::HEIGHT
;        COUNT))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G54
; 
; note: could not stack allocate #:G54 in: (DECLARE-EVENT :GLX-PBUFFER-CLOBBER (CARD16 SEQUENCE) (CARD16 EVENT-TYPE) (CARD16 DRAW-TYPE) (RESOURCE-ID DRAWABLE) (CARD32 BUFFER-MASK) (CARD16 AUX-BUFFER) (CARD16 X Y WIDTH HEIGHT COUNT))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/glx.lisp
; in: DEFUN MAKE-CONTEXT
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB/GLX::CTX 'XLIB/GLX::CONTEXT)
; --> XLIB:WITH-DISPLAY XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN (XLIB:DISPLAY-XID XLIB:DISPLAY))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/glx.lisp
; in: DEFUN QUERY-CONTEXT
;     (LOOP XLIB/GLX::REPEAT XLIB/GLX::NUM-ATTRIBUTES
;           XLIB/GLX::FOR XLIB/GLX::I FIXNUM XLIB/GLX::UPFROM 32 XLIB/GLX::BY 8
;           XLIB/GLX::COLLECTING (CONS (XLIB::CARD32-GET XLIB/GLX::I)
;                                      (XLIB::CARD32-GET (+ XLIB/GLX::I 4))))
; --> BLOCK LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* TAGBODY IF <= IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

; --> BLOCK LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* TAGBODY IF DECF 
; --> SETQ THE SB-IMPL::XSUBTRACT BLOCK 
; ==>
;   (- SB-IMPL::B SB-IMPL::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/glx.lisp
; in: DEFUN GET-DRAWABLE-ATTRIBUTES
;     (LOOP XLIB/GLX::REPEAT XLIB/GLX::NUM-ATTRIBUTES
;           XLIB/GLX::FOR XLIB/GLX::I FIXNUM XLIB/GLX::UPFROM 32 XLIB/GLX::BY 8
;           XLIB/GLX::COLLECTING (CONS (XLIB::CARD32-GET XLIB/GLX::I)
;                                      (XLIB::CARD32-GET (+ XLIB/GLX::I 4))))
; --> BLOCK LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* TAGBODY IF <= IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

; --> BLOCK LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* TAGBODY IF DECF 
; --> SETQ THE SB-IMPL::XSUBTRACT BLOCK 
; ==>
;   (- SB-IMPL::B SB-IMPL::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/glx.lisp
; in: DEFUN GET-VISUAL-CONFIGS
;     (LOOP XLIB/GLX::REPEAT (/ (- XLIB/GLX::NUM-PROPERTIES XLIB/GLX::NUM-ORDERED)
;                               2)
;           XLIB/GLX::COLLECTING (CONS (XLIB::CARD32-GET (INCF XLIB/GLX::INDEX 4))
;                                      (XLIB::CARD32-GET (INCF XLIB/GLX::INDEX 4))))
; --> BLOCK LET CEILING CEILING MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> TRUNCATE LET VALUES LOCALLY 
; ==>
;   (- SB-C::X SB-C::RES)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL -4294967293/2 4294967295/2), not a FIXNUM.
;       The result is a (VALUES (RATIONAL (-1) (1)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a (RATIONAL -4294967293/2 4294967295/2), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (RATIONAL (-1) (1)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; --> BLOCK LET CEILING CEILING MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF AND IF IF PLUSP 
; ==>
;   (> NUMBER 0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a (RATIONAL -4294967293/2 4294967295/2), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (RATIONAL -4294967293/2 4294967295/2), not a FIXNUM.
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/gl.lisp
; in: DEFINE-SEQUENCE-SETTER INT8
;     (XLIB/GL::DEFINE-SEQUENCE-SETTER XLIB:INT8)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK ASSERT TAGBODY LET 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK ASSERT TAGBODY LET SB-KERNEL:ASSERT-ERROR 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/gl.lisp
; in: DEFINE-SEQUENCE-SETTER INT16
;     (XLIB/GL::DEFINE-SEQUENCE-SETTER XLIB:INT16)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK ASSERT TAGBODY LET 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK ASSERT TAGBODY LET SB-KERNEL:ASSERT-ERROR 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/gl.lisp
; in: DEFINE-SEQUENCE-SETTER INT32
;     (XLIB/GL::DEFINE-SEQUENCE-SETTER XLIB:INT32)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK ASSERT TAGBODY LET 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK ASSERT TAGBODY LET SB-KERNEL:ASSERT-ERROR 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/gl.lisp
; in: DEFINE-SEQUENCE-SETTER BOOL
;     (XLIB/GL::DEFINE-SEQUENCE-SETTER XLIB/GL::BOOL)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK ASSERT TAGBODY LET 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK ASSERT TAGBODY LET SB-KERNEL:ASSERT-ERROR 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/gl.lisp
; in: DEFINE-SEQUENCE-SETTER CARD8
;     (XLIB/GL::DEFINE-SEQUENCE-SETTER XLIB:CARD8)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK ASSERT TAGBODY LET 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK ASSERT TAGBODY LET SB-KERNEL:ASSERT-ERROR 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/gl.lisp
; in: DEFINE-SEQUENCE-SETTER CARD16
;     (XLIB/GL::DEFINE-SEQUENCE-SETTER XLIB:CARD16)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK ASSERT TAGBODY LET 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK ASSERT TAGBODY LET SB-KERNEL:ASSERT-ERROR 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/gl.lisp
; in: DEFINE-SEQUENCE-SETTER CARD32
;     (XLIB/GL::DEFINE-SEQUENCE-SETTER XLIB:CARD32)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK ASSERT TAGBODY LET 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK ASSERT TAGBODY LET SB-KERNEL:ASSERT-ERROR 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/gl.lisp
; in: DEFINE-SEQUENCE-SETTER FLOAT32
;     (XLIB/GL::DEFINE-SEQUENCE-SETTER XLIB/GL::FLOAT32)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK ASSERT TAGBODY LET 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK ASSERT TAGBODY LET SB-KERNEL:ASSERT-ERROR 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/gl.lisp
; in: DEFINE-SEQUENCE-SETTER FLOAT64
;     (XLIB/GL::DEFINE-SEQUENCE-SETTER XLIB/GL::FLOAT64)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK ASSERT TAGBODY LET 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK ASSERT TAGBODY LET SB-KERNEL:ASSERT-ERROR 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/randr.lisp
; in: DECLARE-EVENT :RR-SCREEN-CHANGE-NOTIFY
;     (XLIB:DECLARE-EVENT :RR-SCREEN-CHANGE-NOTIFY
;       ((XLIB::DATA (XLIB::MEMBER8 XLIB::+ROTATION-MASK-VECTOR+)))
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:CARD32 XLIB:TIMESTAMP XLIB::CONFIG-TIMESTAMP)
;       (XLIB:WINDOW XLIB::ROOT-WINDOW XLIB::REQUEST-WINDOW)
;       (XLIB:CARD16 XLIB::SIZE-ID XLIB::SUB-PIXEL-ORDER XLIB::WIDTH XLIB::HEIGHT
;        XLIB::WIDTH-IN-MM XLIB::HEIGHT-IN-MM))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G46
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :RR-SCREEN-CHANGE-NOTIFY ((DATA (MEMBER8 +ROTATION-MASK-VECTOR+))) (CARD16 SEQUENCE) (CARD32 TIMESTAMP CONFIG-TIMESTAMP) (WINDOW ROOT-WINDOW REQUEST-WINDOW) (CARD16 SIZE-ID SUB-PIXEL-ORDER WIDTH HEIGHT WIDTH-IN-MM HEIGHT-IN-MM))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/randr.lisp
; in: DECLARE-EVENT :RR-CRTC-CHANGE-NOTIFY
;     (XLIB:DECLARE-EVENT :RR-CRTC-CHANGE-NOTIFY
;       ((XLIB::DATA (XLIB::MEMBER8 XLIB::+ROTATION-MASK-VECTOR+)))
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:CARD32 XLIB:TIMESTAMP)
;       (XLIB:WINDOW XLIB::REQUEST-WINDOW)
;       (XLIB:CARD32 XLIB::CRTC)
;       (XLIB:CARD32 XLIB::MODE)
;       (XLIB:CARD16 XLIB::ROTATION)
;       (XLIB::PAD16)
;       (XLIB:INT16 XLIB::X XLIB::Y)
;       (XLIB:CARD16 XLIB::WIDTH XLIB::HEIGHT))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G45
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :RR-CRTC-CHANGE-NOTIFY ((DATA (MEMBER8 +ROTATION-MASK-VECTOR+))) (CARD16 SEQUENCE) (CARD32 TIMESTAMP) (WINDOW REQUEST-WINDOW) (CARD32 CRTC) (CARD32 MODE) (CARD16 ROTATION) (PAD16) (INT16 X Y) (CARD16 WIDTH HEIGHT))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/randr.lisp
; in: DECLARE-EVENT :RR-OUTPUT-CHANGE-NOTIFY
;     (XLIB:DECLARE-EVENT :RR-OUTPUT-CHANGE-NOTIFY
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:CARD32 XLIB:TIMESTAMP XLIB::CONFIG-TIMESTAMP)
;       (XLIB:WINDOW XLIB::REQUEST-WINDOW)
;       (XLIB:CARD32 XLIB::OUTPUT XLIB::CRTC XLIB::MODE)
;       (XLIB:CARD16 XLIB::ROTATION)
;       (XLIB:CARD8 XLIB::CONNECTION)
;       (XLIB:CARD8 XLIB::SUB-PIXEL-ORDER))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G45
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :RR-OUTPUT-CHANGE-NOTIFY (CARD16 SEQUENCE) (CARD32 TIMESTAMP CONFIG-TIMESTAMP) (WINDOW REQUEST-WINDOW) (CARD32 OUTPUT CRTC MODE) (CARD16 ROTATION) (CARD8 CONNECTION) (CARD8 SUB-PIXEL-ORDER))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/randr.lisp
; in: DECLARE-EVENT :RR-OUTPUT-PROPERTY-NOTIFY
;     (XLIB:DECLARE-EVENT :RR-OUTPUT-PROPERTY-NOTIFY
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW XLIB:WINDOW)
;       (XLIB:CARD32 XLIB::OUTPUT ATOM XLIB:TIMESTAMP)
;       (BOOLEAN XLIB::STATE))
; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET 
; --> VALUES PROG1 LET 
; ==>
;   #:G41
; 
; note: could not stack allocate HANDLER in: (DECLARE-EVENT :RR-OUTPUT-PROPERTY-NOTIFY (CARD16 SEQUENCE) (WINDOW WINDOW) (CARD32 OUTPUT ATOM TIMESTAMP) (BOOLEAN STATE))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/xinerama.lisp
; in: DEFUN XINERAMA-QUERY-SCREENS
;     (INCF XLIB/XINERAMA::INDEX 8)
; ==>
;   (SETQ XLIB/XINERAMA::INDEX (+ 8 XLIB/XINERAMA::INDEX))
; 
; note: doing signed word to integer coercion (cost 20) to INDEX

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/dbe.lisp
; in: DEFUN CREATE-BACK-BUFFER
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB::BB 'XLIB::BACK-BUFFER)
; --> XLIB:WITH-DISPLAY XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN (XLIB:DISPLAY-XID XLIB:DISPLAY))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/clx/414ee220a391ceb13af14ff7dc31bbe114d0c943/clx-20180205-git/extensions/dbe.lisp
; in: DEFUN DBE-GET-VISUAL-INFO
;     (LOOP :FOR XLIB::I :FROM 1 :TO (XLIB::CARD32-GET XLIB::NEXT)
;           :FOR XLIB::OFF := (+ XLIB::NEXT 4) :THEN ...)
; --> BLOCK LET LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* TAGBODY 
; --> SB-LOOP::LOOP-DESETQ 
; ==>
;   (SETQ XLIB::OFF (+ XLIB::NEXT 4))
; 
; note: doing signed word to integer coercion (cost 20) to OFF

; ==>
;   (SETQ XLIB::OFF (+ XLIB::OFF 8))
; 
; note: doing signed word to integer coercion (cost 20) to OFF

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Backends/CLX/medium.lisp
; in: DEFUN CONVERT-INDEXED->MASK
;     (CLIM-CLX::CONVERSION-BODY)
; --> LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION DOTIMES DO BLOCK LET 
; --> TAGBODY TAGBODY DOTIMES DO BLOCK LET TAGBODY TAGBODY LET AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Backends/CLX/medium.lisp
; in: DEFMETHOD TEXT-SIZE (CLX-MEDIUM T)
;     (MAX CLIM-CLX::W CLIM-INTERNALS::WIDTH)
; --> LET LET IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

; --> LET LET IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.

;     (+ CLIM-CLX::ASCENT CLIM-CLX::DESCENT)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (MAX CLIM-CLX::W CLIM-INTERNALS::WIDTH)
; --> LET LET IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

; --> LET LET IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.

;     (+ CLIM-CLX::ASCENT CLIM-CLX::DESCENT CLIM-CLX::H)
; --> + 
; ==>
;   (+ CLIM-CLX::ASCENT CLIM-CLX::DESCENT)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; ==>
;   (+ (+ CLIM-CLX::ASCENT CLIM-CLX::DESCENT) CLIM-CLX::H)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (+ CLIM-CLX::ASCENT CLIM-CLX::DESCENT CLIM-CLX::Y)
; --> + 
; ==>
;   (+ CLIM-CLX::ASCENT CLIM-CLX::DESCENT)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; ==>
;   (+ (+ CLIM-CLX::ASCENT CLIM-CLX::DESCENT) CLIM-CLX::Y)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (+ CLIM-CLX::ASCENT CLIM-CLX::DESCENT CLIM-CLX::BASELINE)
; --> + 
; ==>
;   (+ CLIM-CLX::ASCENT CLIM-CLX::DESCENT)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; ==>
;   (+ (+ CLIM-CLX::ASCENT CLIM-CLX::DESCENT) CLIM-CLX::BASELINE)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.
; in: LAMBDA (IMAGE-ARRAY CONVERTED-DATA MASK-DATA WIDTH HEIGHT INKS)
;     (CLIM-CLX::CONVERSION-BODY)
; --> LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION DOTIMES DO BLOCK LET 
; --> TAGBODY TAGBODY DOTIMES DO BLOCK LET TAGBODY TAGBODY LET AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.
; in: LAMBDA (IMAGE-ARRAY CONVERTED-DATA MASK-DATA WIDTH HEIGHT INKS)
;     (CLIM-CLX::CONVERSION-BODY)
; --> LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION DOTIMES DO BLOCK LET 
; --> TAGBODY TAGBODY DOTIMES DO BLOCK LET TAGBODY TAGBODY LET AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Extensions/image/xpm.lisp
; in: DEFUN XPM-PARSE-COLOR
;     (1-
;      (MCCLIM-IMAGE::XPM-EXIT-STRING MCCLIM-IMAGE::DATA
;       MCCLIM-IMAGE::COLOR-TOKEN-END))
; ==>
;   (-
;    (MCCLIM-IMAGE::XPM-EXIT-STRING MCCLIM-IMAGE::DATA
;     MCCLIM-IMAGE::COLOR-TOKEN-END)
;    1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Extensions/image/xpm.lisp
; in: DEFUN XPM-SUBVECTOR-EQL-P
;     (LOOP MCCLIM-IMAGE::FOR MCCLIM-IMAGE::I MCCLIM-IMAGE::FROM MCCLIM-IMAGE::START MCCLIM-IMAGE::BELOW
;           MCCLIM-IMAGE::END
;           DO (UNLESS
;                  (= (ELT MCCLIM-IMAGE::DATA MCCLIM-IMAGE::I)
;                     (ELT VECTOR (- MCCLIM-IMAGE::I MCCLIM-IMAGE::START)))
;                (RETURN NIL)) RETURN T)
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ + 
; ==>
;   MCCLIM-IMAGE::I
; 
; note: deleting unreachable code

;     (ELT VECTOR (- MCCLIM-IMAGE::I MCCLIM-IMAGE::START))
; --> AREF SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (SIMPLE-ARRAY * (*)), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.

;     (= (ELT MCCLIM-IMAGE::DATA MCCLIM-IMAGE::I)
;        (ELT VECTOR (- MCCLIM-IMAGE::I MCCLIM-IMAGE::START)))
; 
; note: unable to open code because: The operands might not be the same type.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Extensions/image/xpm.lisp
; in: DEFUN XPM-PARSE-INTEGER-HEX
;     (ASH MCCLIM-IMAGE::ACCUMULATOR 4)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.

;     (+ (ASH MCCLIM-IMAGE::ACCUMULATOR 4)
;        (COND ((<= 48 BYTE 57) (- BYTE 48)) ((<= 65 BYTE 70) (- BYTE 65 -10))
;              ((<= 97 BYTE 102) (- BYTE 97 -10))
;              (T (ERROR "Unknown hex digit ~A, this should be impossible." BYTE))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Extensions/image/xpm.lisp
; in: DEFUN XPM-PARSE-SINGLE-COLOR-2
;     (MOD (- MCCLIM-IMAGE::END MCCLIM-IMAGE::START 1) 3)
; --> LET REM NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (TRUNCATE NUMBER SB-C::DIVISOR)
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a (INTEGER -4611686018427387901 4611686018427387899), not a (UNSIGNED-BYTE 64).

;     (EXPT 2 MCCLIM-IMAGE::W)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (RATIONAL -18446744073709551604/3 18446744073709551596/3), not a INTEGER.
; 
; note: unable to optimize due to type uncertainty: The second argument is a (RATIONAL -18446744073709551604/3 18446744073709551596/3), not a UNSIGNED-BYTE.

;     (* 2 MCCLIM-IMAGE::W)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a (RATIONAL -18446744073709551604/3 18446744073709551596/3), not a INTEGER.

;     (LDB (BYTE MCCLIM-IMAGE::W (* 2 MCCLIM-IMAGE::W)) MCCLIM-IMAGE::X)
; ==>
;   (SB-KERNEL:%LDB MCCLIM-IMAGE::W (* 2 MCCLIM-IMAGE::W) MCCLIM-IMAGE::X)
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).

;     (/ (LDB (BYTE MCCLIM-IMAGE::W (* 2 MCCLIM-IMAGE::W)) MCCLIM-IMAGE::X)
;        MCCLIM-IMAGE::M)
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The second argument is a (OR (SINGLE-FLOAT -1.0) (RATIONAL -1)), not a INTEGER.

;     (LDB (BYTE MCCLIM-IMAGE::W (* 1 MCCLIM-IMAGE::W)) MCCLIM-IMAGE::X)
; ==>
;   (SB-KERNEL:%LDB MCCLIM-IMAGE::W (* 1 MCCLIM-IMAGE::W) MCCLIM-IMAGE::X)
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).

;     (/ (LDB (BYTE MCCLIM-IMAGE::W (* 1 MCCLIM-IMAGE::W)) MCCLIM-IMAGE::X)
;        MCCLIM-IMAGE::M)
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The second argument is a (OR (SINGLE-FLOAT -1.0) (RATIONAL -1)), not a INTEGER.

;     (LDB (BYTE MCCLIM-IMAGE::W (* 0 MCCLIM-IMAGE::W)) MCCLIM-IMAGE::X)
; ==>
;   (SB-KERNEL:%LDB MCCLIM-IMAGE::W (* 0 MCCLIM-IMAGE::W) MCCLIM-IMAGE::X)
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).

;     (/ (LDB (BYTE MCCLIM-IMAGE::W (* 0 MCCLIM-IMAGE::W)) MCCLIM-IMAGE::X)
;        MCCLIM-IMAGE::M)
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The second argument is a (OR (SINGLE-FLOAT -1.0) (RATIONAL -1)), not a INTEGER.

;     (1- (EXPT 2 MCCLIM-IMAGE::W))
; ==>
;   (- (EXPT 2 MCCLIM-IMAGE::W) 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (OR (RATIONAL 0) (SINGLE-FLOAT 0.0)), not a FIXNUM.
;       The result is a (VALUES (OR (SINGLE-FLOAT -1.0) (RATIONAL -1)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (RATIONAL 0) (SINGLE-FLOAT 0.0)), not a FIXNUM.
;       The result is a (VALUES (OR (SINGLE-FLOAT -1.0) (RATIONAL -1)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (* 2 MCCLIM-IMAGE::W)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 3) because:
;       The first argument is a (RATIONAL -18446744073709551604/3 18446744073709551596/3), not a FIXNUM.
;       The result is a (VALUES (RATIONAL -36893488147419103208/3 36893488147419103192/3) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a (RATIONAL -18446744073709551604/3 18446744073709551596/3), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (RATIONAL -36893488147419103208/3 36893488147419103192/3) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
WARNING: redefining CLIM-CLX::INITIALIZE-CLX in DEFGENERIC
WARNING: redefining ZPB-TTF::LOCATION in DEFGENERIC

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-vectors/55f19b15187b1a1026c7fd139fedf3cb7663847b/cl-vectors-20180205-git/aa.lisp
; in: DEFUN SCANLINE-SWEEP
;     (FUNCALL NET.TUXEE.AA::FUNCTION-SPAN NET.TUXEE.AA::START-X
;              NET.TUXEE.AA::END-X NET.TUXEE.AA::Y NET.TUXEE.AA::ALPHA)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN NET.TUXEE.AA::FUNCTION-SPAN)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: FUNCTION-SPAN is not known to be a function

;     (FUNCALL FUNCTION NET.TUXEE.AA::IX NET.TUXEE.AA::Y NET.TUXEE.AA::ALPHA)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: FUNCTION is not known to be a function

;     (LOOP NET.TUXEE.AA::FOR NET.TUXEE.AA::IX NET.TUXEE.AA::FROM NET.TUXEE.AA::START-X NET.TUXEE.AA::BELOW NET.TUXEE.AA::END-X
;           DO (FUNCALL FUNCTION NET.TUXEE.AA::IX NET.TUXEE.AA::Y
;                       NET.TUXEE.AA::ALPHA))
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ NET.TUXEE.AA::IX 1)
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (NET.TUXEE.AA::COMPUTE-ALPHA NET.TUXEE.AA::COVER
;      (NET.TUXEE.AA::CELL-AREA NET.TUXEE.AA::CELL))
; --> BLOCK TRUNCATE - * 
; ==>
;   (* 512 NET.TUXEE.AA::COVER)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to associate */(* /) of constants due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

; --> BLOCK 
; ==>
;   (TRUNCATE
;    (- (* 2 NET.TUXEE.AA::+CELL-WIDTH+ NET.TUXEE.AA::COVER) NET.TUXEE.AA::AREA)
;    NET.TUXEE.AA::+ALPHA-DIVISOR+)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to convert division by 2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a REAL, not a (UNSIGNED-BYTE 64).

;     (FUNCALL FUNCTION NET.TUXEE.AA::X NET.TUXEE.AA::Y NET.TUXEE.AA::ALPHA)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: FUNCTION is not known to be a function

;     (NET.TUXEE.AA::COMPUTE-ALPHA NET.TUXEE.AA::COVER 0)
; --> BLOCK TRUNCATE - * 
; ==>
;   (* 512 NET.TUXEE.AA::COVER)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to associate */(* /) of constants due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

; --> BLOCK TRUNCATE 
; ==>
;   (- (* 2 NET.TUXEE.AA::+CELL-WIDTH+ NET.TUXEE.AA::COVER) NET.TUXEE.AA::AREA)
; 
; note: unable to fold zero arg due to type uncertainty: The first argument is a NUMBER, not a (OR RATIONAL (COMPLEX RATIONAL)).

; --> BLOCK 
; ==>
;   (TRUNCATE
;    (- (* 2 NET.TUXEE.AA::+CELL-WIDTH+ NET.TUXEE.AA::COVER) NET.TUXEE.AA::AREA)
;    NET.TUXEE.AA::+ALPHA-DIVISOR+)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to convert division by 2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a REAL, not a (UNSIGNED-BYTE 64).

;     (MAX NET.TUXEE.AA::START (1+ NET.TUXEE.AA::LAST-X))
; --> LET LET IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

; --> LET LET IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (MIN NET.TUXEE.AA::END NET.TUXEE.AA::X)
; --> LET LET IF <= OR LET < IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

; --> LET LET IF <= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP NET.TUXEE.AA::FOR NET.TUXEE.AA::IX NET.TUXEE.AA::FROM NET.TUXEE.AA::START-X NET.TUXEE.AA::BELOW NET.TUXEE.AA::END-X
;           DO (FUNCALL FUNCTION NET.TUXEE.AA::IX NET.TUXEE.AA::Y
;                       NET.TUXEE.AA::ALPHA))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.

; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

;     (>= NET.TUXEE.AA::X NET.TUXEE.AA::END)
; --> OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (< (NET.TUXEE.AA::CELL-X (CAR NET.TUXEE.AA::CELLS)) NET.TUXEE.AA::START)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

;     (INCF NET.TUXEE.AA::COVER
;           (NET.TUXEE.AA::CELL-COVER (CAR NET.TUXEE.AA::CELLS)))
; --> SETQ THE 
; ==>
;   (+ (NET.TUXEE.AA::CELL-COVER (CAR NET.TUXEE.AA::CELLS)) NET.TUXEE.AA::COVER)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (1+ NET.TUXEE.AA::LAST-X)
; ==>
;   (+ NET.TUXEE.AA::LAST-X 1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (> NET.TUXEE.AA::X (1+ NET.TUXEE.AA::LAST-X))
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.

;     (NET.TUXEE.AA::COMPUTE-ALPHA NET.TUXEE.AA::COVER 0)
; --> BLOCK TRUNCATE - * 
; ==>
;   (* 512 NET.TUXEE.AA::COVER)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; --> BLOCK TRUNCATE 
; ==>
;   (- (* 2 NET.TUXEE.AA::+CELL-WIDTH+ NET.TUXEE.AA::COVER) NET.TUXEE.AA::AREA)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (1+ NET.TUXEE.AA::LAST-X)
; ==>
;   (+ NET.TUXEE.AA::LAST-X 1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (MAX NET.TUXEE.AA::START (1+ NET.TUXEE.AA::LAST-X))
; --> LET LET IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.

;     (MIN NET.TUXEE.AA::END NET.TUXEE.AA::X)
; --> LET LET IF <= OR LET < IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.

;     (LOOP NET.TUXEE.AA::FOR NET.TUXEE.AA::IX NET.TUXEE.AA::FROM NET.TUXEE.AA::START-X NET.TUXEE.AA::BELOW NET.TUXEE.AA::END-X
;           DO (FUNCALL FUNCTION NET.TUXEE.AA::IX NET.TUXEE.AA::Y
;                       NET.TUXEE.AA::ALPHA))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.

; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ NET.TUXEE.AA::IX 1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (>= NET.TUXEE.AA::X NET.TUXEE.AA::END)
; --> OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

;     (INCF NET.TUXEE.AA::COVER (NET.TUXEE.AA::CELL-COVER NET.TUXEE.AA::CELL))
; --> SETQ THE 
; ==>
;   (+ (NET.TUXEE.AA::CELL-COVER NET.TUXEE.AA::CELL) NET.TUXEE.AA::COVER)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (NET.TUXEE.AA::COMPUTE-ALPHA NET.TUXEE.AA::COVER
;      (NET.TUXEE.AA::CELL-AREA NET.TUXEE.AA::CELL))
; --> BLOCK TRUNCATE - * 
; ==>
;   (* 512 NET.TUXEE.AA::COVER)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; --> BLOCK TRUNCATE 
; ==>
;   (- (* 2 NET.TUXEE.AA::+CELL-WIDTH+ NET.TUXEE.AA::COVER) NET.TUXEE.AA::AREA)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-vectors/55f19b15187b1a1026c7fd139fedf3cb7663847b/cl-vectors-20180205-git/aa-bin.lisp
; in: DEFUN MAP-LINE-INTERSECTIONS
;     (/= NET.TUXEE.AA-BIN::Y1 NET.TUXEE.AA-BIN::Y2)
; --> IF 
; ==>
;   (= NET.TUXEE.AA-BIN::Y1 NET.TUXEE.AA-BIN::Y2)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)).The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

;     (> NET.TUXEE.AA-BIN::Y1 NET.TUXEE.AA-BIN::Y2)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.

;     (CEILING NET.TUXEE.AA-BIN::Y1 NET.TUXEE.AA-BIN::+CELL-WIDTH+)
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (TRUNCATE NUMBER SB-C::DIVISOR)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to convert division by 2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a REAL, not a (UNSIGNED-BYTE 64).

;     (FLOOR (1- NET.TUXEE.AA-BIN::Y2) NET.TUXEE.AA-BIN::+CELL-WIDTH+)
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (TRUNCATE NUMBER SB-C::DIVISOR)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to convert division by 2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a REAL, not a (UNSIGNED-BYTE 64).

; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF NOT IF ZEROP 
; ==>
;   (= REM 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (RATIONAL (-256) (256)) DOUBLE-FLOAT SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF MINUSP 
; ==>
;   (< NUMBER 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (CEILING NET.TUXEE.AA-BIN::Y1 NET.TUXEE.AA-BIN::+CELL-WIDTH+)
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF NOT IF ZEROP 
; ==>
;   (= REM 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (RATIONAL (-256) (256)) DOUBLE-FLOAT SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF PLUSP 
; ==>
;   (> NUMBER 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (FUNCALL FUNCTION
;              (+ NET.TUXEE.AA-BIN::X1
;                 (FLOOR
;                  (* NET.TUXEE.AA-BIN::DX
;                     (- NET.TUXEE.AA-BIN::N NET.TUXEE.AA-BIN::Y1))
;                  NET.TUXEE.AA-BIN::DY))
;              NET.TUXEE.AA-BIN::N)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: FUNCTION is not known to be a function

;     (* NET.TUXEE.AA-BIN::DX (- NET.TUXEE.AA-BIN::N NET.TUXEE.AA-BIN::Y1))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a REAL, not a INTEGER.

;     (FLOOR (* NET.TUXEE.AA-BIN::DX (- NET.TUXEE.AA-BIN::N NET.TUXEE.AA-BIN::Y1))
;            NET.TUXEE.AA-BIN::DY)
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (TRUNCATE NUMBER SB-C::DIVISOR)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a (OR DOUBLE-FLOAT SINGLE-FLOAT INTEGER).

; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF NOT IF ZEROP 
; ==>
;   (= REM 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF MINUSP 
; ==>
;   (< SB-C::DIVISOR 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF PLUSP 
; ==>
;   (> NUMBER 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF MINUSP 
; ==>
;   (< NUMBER 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (/= NET.TUXEE.AA-BIN::Y1 NET.TUXEE.AA-BIN::Y2)
; --> IF 
; ==>
;   (= NET.TUXEE.AA-BIN::Y1 NET.TUXEE.AA-BIN::Y2)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       etc.

;     (> NET.TUXEE.AA-BIN::Y1 NET.TUXEE.AA-BIN::Y2)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (- NET.TUXEE.AA-BIN::X2 NET.TUXEE.AA-BIN::X1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (- NET.TUXEE.AA-BIN::Y2 NET.TUXEE.AA-BIN::Y1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (CEILING NET.TUXEE.AA-BIN::Y1 NET.TUXEE.AA-BIN::+CELL-WIDTH+)
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF PLUSP 
; ==>
;   (> NUMBER 0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 
; ==>
;   (+ SB-C::TRU 1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (* NET.TUXEE.AA-BIN::+CELL-WIDTH+
;        (CEILING NET.TUXEE.AA-BIN::Y1 NET.TUXEE.AA-BIN::+CELL-WIDTH+))
; ==>
;   (ASH SB-C::X 8)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.

;     (1- NET.TUXEE.AA-BIN::Y2)
; ==>
;   (- NET.TUXEE.AA-BIN::Y2 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (FLOOR (1- NET.TUXEE.AA-BIN::Y2) NET.TUXEE.AA-BIN::+CELL-WIDTH+)
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF MINUSP 
; ==>
;   (< NUMBER 0)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 1- 
; ==>
;   (- SB-C::TRU 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (* NET.TUXEE.AA-BIN::+CELL-WIDTH+
;        (FLOOR (1- NET.TUXEE.AA-BIN::Y2) NET.TUXEE.AA-BIN::+CELL-WIDTH+))
; ==>
;   (ASH SB-C::X 8)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.

;     (LOOP NET.TUXEE.AA-BIN::FOR NET.TUXEE.AA-BIN::N NET.TUXEE.AA-BIN::FROM (*
;                                                                             NET.TUXEE.AA-BIN::+CELL-WIDTH+
;                                                                             (CEILING
;                                                                              NET.TUXEE.AA-BIN::Y1
;                                                                              NET.TUXEE.AA-BIN::+CELL-WIDTH+)) NET.TUXEE.AA-BIN::UPTO (*
;                                                                                                                                       NET.TUXEE.AA-BIN::+CELL-WIDTH+
;                                                                                                                                       (FLOOR
;                                                                                                                                        (1-
;                                                                                                                                         NET.TUXEE.AA-BIN::Y2)
;                                                                                                                                        NET.TUXEE.AA-BIN::+CELL-WIDTH+)) NET.TUXEE.AA-BIN::BY NET.TUXEE.AA-BIN::+CELL-WIDTH+
;           DO (FUNCALL FUNCTION
;                       (+ NET.TUXEE.AA-BIN::X1
;                          (FLOOR (* NET.TUXEE.AA-BIN::DX #) NET.TUXEE.AA-BIN::DY))
;                       NET.TUXEE.AA-BIN::N))
; --> BLOCK LET TAGBODY WHEN IF 
; ==>
;   (> NET.TUXEE.AA-BIN::N #:LOOP-LIMIT-0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.

;     (- NET.TUXEE.AA-BIN::N NET.TUXEE.AA-BIN::Y1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The second argument is a REAL, not a (SIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (* NET.TUXEE.AA-BIN::DX (- NET.TUXEE.AA-BIN::N NET.TUXEE.AA-BIN::Y1))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       unable to do inline fixnum arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (FLOOR (* NET.TUXEE.AA-BIN::DX (- NET.TUXEE.AA-BIN::N NET.TUXEE.AA-BIN::Y1))
;            NET.TUXEE.AA-BIN::DY)
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF MINUSP 
; ==>
;   (< SB-C::DIVISOR 0)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; ==>
;   (< NUMBER 0)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF PLUSP 
; ==>
;   (> NUMBER 0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 1- 
; ==>
;   (- SB-C::TRU 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (+ NET.TUXEE.AA-BIN::X1
;        (FLOOR
;         (* NET.TUXEE.AA-BIN::DX (- NET.TUXEE.AA-BIN::N NET.TUXEE.AA-BIN::Y1))
;         NET.TUXEE.AA-BIN::DY))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (LOOP NET.TUXEE.AA-BIN::FOR NET.TUXEE.AA-BIN::N NET.TUXEE.AA-BIN::FROM (*
;                                                                             NET.TUXEE.AA-BIN::+CELL-WIDTH+
;                                                                             (CEILING
;                                                                              NET.TUXEE.AA-BIN::Y1
;                                                                              NET.TUXEE.AA-BIN::+CELL-WIDTH+)) NET.TUXEE.AA-BIN::UPTO (*
;                                                                                                                                       NET.TUXEE.AA-BIN::+CELL-WIDTH+
;                                                                                                                                       (FLOOR
;                                                                                                                                        (1-
;                                                                                                                                         NET.TUXEE.AA-BIN::Y2)
;                                                                                                                                        NET.TUXEE.AA-BIN::+CELL-WIDTH+)) NET.TUXEE.AA-BIN::BY NET.TUXEE.AA-BIN::+CELL-WIDTH+
;           DO (FUNCALL FUNCTION
;                       (+ NET.TUXEE.AA-BIN::X1
;                          (FLOOR (* NET.TUXEE.AA-BIN::DX #) NET.TUXEE.AA-BIN::DY))
;                       NET.TUXEE.AA-BIN::N))
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 
; ==>
;   (+ NET.TUXEE.AA-BIN::N 256)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Extensions/fonts/fontconfig.lisp
; in: DEFUN FIND-FONTCONFIG-FONT
;     (WITH-INPUT-FROM-STRING (STREAM MCCLIM-TRUETYPE::OUTPUT)
;       (MCCLIM-TRUETYPE::PARSE-FONTCONFIG-OUTPUT STREAM))
; --> LET 
; ==>
;   (MULTIPLE-VALUE-PROG1
;       (UNWIND-PROTECT (PROGN (MCCLIM-TRUETYPE::PARSE-FONTCONFIG-OUTPUT STREAM))
;         (CLOSE STREAM)))
; 
; note: type assertion too complex to check:
; (VALUES (OR PATHNAME NULL) &OPTIONAL (OR NULL (MOD 4611686018427387901))).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Extensions/fonts/mcclim-native-ttf.lisp
; in: DEFUN GLYPH-PIXARRAY
;     (LET* ((MCCLIM-TRUETYPE::GLYPH
;             (ZPB-TTF:FIND-GLYPH CHAR (MCCLIM-TRUETYPE::ZPB-TTF-FONT-LOADER #)))
;            (MCCLIM-TRUETYPE::LEFT-SIDE-BEARING
;             (* MCCLIM-TRUETYPE::UNITS->PIXELS
;                (ZPB-TTF:LEFT-SIDE-BEARING MCCLIM-TRUETYPE::GLYPH)))
;            (MCCLIM-TRUETYPE::RIGHT-SIDE-BEARING
;             (* MCCLIM-TRUETYPE::UNITS->PIXELS
;                (ZPB-TTF:RIGHT-SIDE-BEARING MCCLIM-TRUETYPE::GLYPH)))
;            (MCCLIM-TRUETYPE::ADVANCE-WIDTH
;             (* MCCLIM-TRUETYPE::UNITS->PIXELS
;                (ZPB-TTF:ADVANCE-WIDTH MCCLIM-TRUETYPE::GLYPH)))
;            (MCCLIM-TRUETYPE::BOUNDING-BOX
;             (MAP 'VECTOR (LAMBDA # #)
;                  (ZPB-TTF:BOUNDING-BOX MCCLIM-TRUETYPE::GLYPH)))
;            (MCCLIM-TRUETYPE::MIN-X (ELT MCCLIM-TRUETYPE::BOUNDING-BOX 0))
;            (MCCLIM-TRUETYPE::MIN-Y (ELT MCCLIM-TRUETYPE::BOUNDING-BOX 1))
;            (MCCLIM-TRUETYPE::MAX-X (ELT MCCLIM-TRUETYPE::BOUNDING-BOX 2))
;            (MCCLIM-TRUETYPE::MAX-Y (ELT MCCLIM-TRUETYPE::BOUNDING-BOX 3))
;            (MCCLIM-TRUETYPE::WIDTH
;             (- (CEILING MCCLIM-TRUETYPE::MAX-X) (FLOOR MCCLIM-TRUETYPE::MIN-X)))
;            (MCCLIM-TRUETYPE::HEIGHT
;             (- (CEILING MCCLIM-TRUETYPE::MAX-Y) (FLOOR MCCLIM-TRUETYPE::MIN-Y)))
;            (ARRAY
;             (MAKE-ARRAY (LIST MCCLIM-TRUETYPE::HEIGHT MCCLIM-TRUETYPE::WIDTH)
;                         :INITIAL-ELEMENT 0 :ELEMENT-TYPE '(UNSIGNED-BYTE 8)))
;            ...)
;       (ASSERT
;        (<= (ELT MCCLIM-TRUETYPE::BOUNDING-BOX 0)
;            (ELT MCCLIM-TRUETYPE::BOUNDING-BOX 2)))
;       (ASSERT
;        (<= (ELT MCCLIM-TRUETYPE::BOUNDING-BOX 1)
;            (ELT MCCLIM-TRUETYPE::BOUNDING-BOX 3)))
;       (DOLIST (CLIM:PATH MCCLIM-TRUETYPE::PATHS)
;         (NET.TUXEE.VECTORS:UPDATE-STATE MCCLIM-TRUETYPE::STATE CLIM:PATH))
;       (NET.TUXEE.AA:CELLS-SWEEP MCCLIM-TRUETYPE::STATE
;                                 (LAMBDA
;                                     (MCCLIM-TRUETYPE::X MCCLIM-TRUETYPE::Y
;                                      MCCLIM-TRUETYPE::ALPHA)
;                                   (WHEN (AND # #) (SETF #))))
;       (VALUES ARRAY (FLOOR MCCLIM-TRUETYPE::MIN-X)
;               (CEILING MCCLIM-TRUETYPE::MAX-Y)
;               (ROUND MCCLIM-TRUETYPE::ADVANCE-WIDTH) 0))
; 
; caught STYLE-WARNING:
;   The variable LEFT-SIDE-BEARING is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable RIGHT-SIDE-BEARING is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "mcclim-fonts/truetype" "mcclim-native-ttf">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Extensions/fonts/xrender-fonts.lisp
; in: DEFMETHOD CLIM-CLX::FONT-TEXT-EXTENTS (TRUETYPE-FONT T)
;     (LENGTH STRING)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (DEFMETHOD CLIM-CLX::FONT-TEXT-EXTENTS
;                ((MCCLIM-TRUETYPE::FONT MCCLIM-TRUETYPE::TRUETYPE-FONT) STRING
;                 &KEY (MCCLIM-TRUETYPE::START 0)
;                 (MCCLIM-TRUETYPE::END (LENGTH STRING))
;                 MCCLIM-TRUETYPE::TRANSLATE)
;       (DECLARE (OPTIMIZE (SPEED 3))
;                (IGNORE MCCLIM-TRUETYPE::TRANSLATE))
;       (LET ((MCCLIM-TRUETYPE::WIDTH
;              (MACROLET #
;                #)))
;         (VALUES MCCLIM-TRUETYPE::WIDTH
;                 (CLIM-CLX::FONT-ASCENT MCCLIM-TRUETYPE::FONT)
;                 (CLIM-CLX::FONT-DESCENT MCCLIM-TRUETYPE::FONT)
;                 (CLIM-CLX::FONT-GLYPH-LEFT MCCLIM-TRUETYPE::FONT
;                  (CHAR STRING MCCLIM-TRUETYPE::START))
;                 (- MCCLIM-TRUETYPE::WIDTH (- # #))
;                 (CLIM-CLX::FONT-ASCENT MCCLIM-TRUETYPE::FONT)
;                 (CLIM-CLX::FONT-DESCENT MCCLIM-TRUETYPE::FONT) 0
;                 MCCLIM-TRUETYPE::END)))
; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF 
; ==>
;   (*
;    (SB-PCL::OPTIMIZED-SLOT-VALUE
;     (SLOT-VALUE MCCLIM-TRUETYPE::FONT 'MCCLIM-TRUETYPE::FIXED-WIDTH)
;     MCCLIM-TRUETYPE::FONT
;     (SB-PCL::INSTANCE-READ (SB-PCL::PV-OFFSET 2) MCCLIM-TRUETYPE::FONT 0
;                            'MCCLIM-TRUETYPE::FIXED-WIDTH
;                            '#<STANDARD-CLASS MCCLIM-TRUETYPE::TRUETYPE-FONT>))
;    (- MCCLIM-TRUETYPE::END MCCLIM-TRUETYPE::START))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF LET IF IF PROGN LOCALLY 
; --> BLOCK LET LET LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY 
; --> SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

;     (CHAR STRING MCCLIM-TRUETYPE::START)
; --> AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

;     (CHAR STRING (1- MCCLIM-TRUETYPE::END))
; --> AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

;     (DEFMETHOD CLIM-CLX::FONT-TEXT-EXTENTS
;                ((MCCLIM-TRUETYPE::FONT MCCLIM-TRUETYPE::TRUETYPE-FONT) STRING
;                 &KEY (MCCLIM-TRUETYPE::START 0)
;                 (MCCLIM-TRUETYPE::END (LENGTH STRING))
;                 MCCLIM-TRUETYPE::TRANSLATE)
;       (DECLARE (OPTIMIZE (SPEED 3))
;                (IGNORE MCCLIM-TRUETYPE::TRANSLATE))
;       (LET ((MCCLIM-TRUETYPE::WIDTH
;              (MACROLET #
;                #)))
;         (VALUES MCCLIM-TRUETYPE::WIDTH
;                 (CLIM-CLX::FONT-ASCENT MCCLIM-TRUETYPE::FONT)
;                 (CLIM-CLX::FONT-DESCENT MCCLIM-TRUETYPE::FONT)
;                 (CLIM-CLX::FONT-GLYPH-LEFT MCCLIM-TRUETYPE::FONT
;                  (CHAR STRING MCCLIM-TRUETYPE::START))
;                 (- MCCLIM-TRUETYPE::WIDTH (- # #))
;                 (CLIM-CLX::FONT-ASCENT MCCLIM-TRUETYPE::FONT)
;                 (CLIM-CLX::FONT-DESCENT MCCLIM-TRUETYPE::FONT) 0
;                 MCCLIM-TRUETYPE::END)))
; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF LET IF IF THE PROGN 
; --> BLOCK LET LET LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY 
; --> SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF LET IF IF PROGN LOCALLY 
; --> BLOCK LET LET LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY WHEN IF >= OR 
; --> LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF LET IF IF PROGN LOCALLY 
; --> BLOCK LET LET LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY WHEN IF >= OR 
; --> LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF LET IF IF THE PROGN 
; --> BLOCK LET LET LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY WHEN IF >= OR 
; --> LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF LET IF IF THE PROGN 
; --> BLOCK LET LET LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY WHEN IF >= OR 
; --> LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF LET IF PROGN LOCALLY 
; --> BLOCK LET LET LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY WHEN IF >= OR 
; --> LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF LET IF PROGN LOCALLY 
; --> BLOCK LET LET LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY WHEN IF >= OR 
; --> LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

;     (- MCCLIM-TRUETYPE::END MCCLIM-TRUETYPE::START)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (DEFMETHOD CLIM-CLX::FONT-TEXT-EXTENTS
;                ((MCCLIM-TRUETYPE::FONT MCCLIM-TRUETYPE::TRUETYPE-FONT) STRING
;                 &KEY (MCCLIM-TRUETYPE::START 0)
;                 (MCCLIM-TRUETYPE::END (LENGTH STRING))
;                 MCCLIM-TRUETYPE::TRANSLATE)
;       (DECLARE (OPTIMIZE (SPEED 3))
;                (IGNORE MCCLIM-TRUETYPE::TRANSLATE))
;       (LET ((MCCLIM-TRUETYPE::WIDTH
;              (MACROLET #
;                #)))
;         (VALUES MCCLIM-TRUETYPE::WIDTH
;                 (CLIM-CLX::FONT-ASCENT MCCLIM-TRUETYPE::FONT)
;                 (CLIM-CLX::FONT-DESCENT MCCLIM-TRUETYPE::FONT)
;                 (CLIM-CLX::FONT-GLYPH-LEFT MCCLIM-TRUETYPE::FONT
;                  (CHAR STRING MCCLIM-TRUETYPE::START))
;                 (- MCCLIM-TRUETYPE::WIDTH (- # #))
;                 (CLIM-CLX::FONT-ASCENT MCCLIM-TRUETYPE::FONT)
;                 (CLIM-CLX::FONT-DESCENT MCCLIM-TRUETYPE::FONT) 0
;                 MCCLIM-TRUETYPE::END)))
; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF 
; ==>
;   (*
;    (SB-PCL::OPTIMIZED-SLOT-VALUE
;     (SLOT-VALUE MCCLIM-TRUETYPE::FONT 'MCCLIM-TRUETYPE::FIXED-WIDTH)
;     MCCLIM-TRUETYPE::FONT
;     (SB-PCL::INSTANCE-READ (SB-PCL::PV-OFFSET 2) MCCLIM-TRUETYPE::FONT 0
;                            'MCCLIM-TRUETYPE::FIXED-WIDTH
;                            '#<STANDARD-CLASS MCCLIM-TRUETYPE::TRUETYPE-FONT>))
;    (- MCCLIM-TRUETYPE::END MCCLIM-TRUETYPE::START))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF LET IF IF THE PROGN 
; --> BLOCK LET LET LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY WHEN IF >= OR 
; --> LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF LET IF IF THE PROGN 
; --> BLOCK LET LET LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY WHEN IF >= OR 
; --> LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF LET IF IF THE PROGN 
; --> BLOCK LET LET LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-8
;      (OR
;       (MCCLIM-TRUETYPE::GCACHE-GET MCCLIM-TRUETYPE::WIDTH-CACHE
;        MCCLIM-TRUETYPE::CODE)
;       (MCCLIM-TRUETYPE::GCACHE-SET MCCLIM-TRUETYPE::WIDTH-CACHE
;        MCCLIM-TRUETYPE::CODE
;        (CLIM-CLX::FONT-GLYPH-WIDTH MCCLIM-TRUETYPE::FONT CHAR))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF LET IF IF PROGN LOCALLY 
; --> BLOCK LET LET LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY WHEN IF >= OR 
; --> LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF LET IF IF PROGN LOCALLY 
; --> BLOCK LET LET LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY WHEN IF >= OR 
; --> LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF LET IF IF PROGN LOCALLY 
; --> BLOCK LET LET LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-5
;      (OR
;       (MCCLIM-TRUETYPE::GCACHE-GET MCCLIM-TRUETYPE::WIDTH-CACHE
;        MCCLIM-TRUETYPE::CODE)
;       (MCCLIM-TRUETYPE::GCACHE-SET MCCLIM-TRUETYPE::WIDTH-CACHE
;        MCCLIM-TRUETYPE::CODE
;        (CLIM-CLX::FONT-GLYPH-WIDTH MCCLIM-TRUETYPE::FONT CHAR))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF LET IF PROGN LOCALLY 
; --> BLOCK LET LET LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY WHEN IF >= OR 
; --> LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF LET IF PROGN LOCALLY 
; --> BLOCK LET LET LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY WHEN IF >= OR 
; --> LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS 
; --> LET* LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 
; --> SB-PCL::PV-ENV LOCALLY LET BLOCK LET MACROLET IF LET IF PROGN LOCALLY 
; --> BLOCK LET LET LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-2
;      (OR
;       (MCCLIM-TRUETYPE::GCACHE-GET MCCLIM-TRUETYPE::WIDTH-CACHE
;        MCCLIM-TRUETYPE::CODE)
;       (MCCLIM-TRUETYPE::GCACHE-SET MCCLIM-TRUETYPE::WIDTH-CACHE
;        MCCLIM-TRUETYPE::CODE
;        (CLIM-CLX::FONT-GLYPH-WIDTH MCCLIM-TRUETYPE::FONT CHAR))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (1- MCCLIM-TRUETYPE::END)
; ==>
;   (- MCCLIM-TRUETYPE::END 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (-
;      (CLIM-CLX::FONT-GLYPH-WIDTH MCCLIM-TRUETYPE::FONT
;                                  (CHAR STRING (1- MCCLIM-TRUETYPE::END)))
;      (CLIM-CLX::FONT-GLYPH-RIGHT MCCLIM-TRUETYPE::FONT
;       (CHAR STRING (1- MCCLIM-TRUETYPE::END))))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (- MCCLIM-TRUETYPE::WIDTH
;        (-
;         (CLIM-CLX::FONT-GLYPH-WIDTH MCCLIM-TRUETYPE::FONT
;                                     (CHAR STRING (1- MCCLIM-TRUETYPE::END)))
;         (CLIM-CLX::FONT-GLYPH-RIGHT MCCLIM-TRUETYPE::FONT
;          (CHAR STRING (1- MCCLIM-TRUETYPE::END)))))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Extensions/fonts/xrender-fonts.lisp
; in: DEFMETHOD CLIM-CLX::FONT-DRAW-GLYPHS (TRUETYPE-FONT T T T T T)
;     (AREF STRING MCCLIM-TRUETYPE::I)
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.
WARNING: redefining (SETF MEDIUM-TEXT-STYLE) :BEFORE (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:T> #<STANDARD-CLASS CLIM-CLX::CLX-MEDIUM>) in DEFMETHOD
WARNING: redefining CLIM-TAB-LAYOUT:TAB-LAYOUT-PAGES in DEFGENERIC
WARNING: redefining CLIM-TAB-LAYOUT:TAB-LAYOUT-ENABLED-PAGE in DEFGENERIC
WARNING: redefining CLIM-TAB-LAYOUT:TAB-PAGE-TAB-LAYOUT in DEFGENERIC
WARNING: redefining CLIM-TAB-LAYOUT:TAB-PAGE-PANE in DEFGENERIC
WARNING: redefining CLIM-TAB-LAYOUT:TAB-PAGE-TITLE in DEFGENERIC
WARNING: redefining CLIM-TAB-LAYOUT:TAB-PAGE-PRESENTATION-TYPE in DEFGENERIC
WARNING: redefining CLIM-TAB-LAYOUT:TAB-PAGE-DRAWING-OPTIONS in DEFGENERIC
WARNING: redefining (COMMON-LISP:SETF CLIM-TAB-LAYOUT:TAB-LAYOUT-ENABLED-PAGE) in DEFGENERIC

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Extensions/render/cl-vectors/vectors.lisp
; in: DEFUN %AA-SCANLINE-SWEEP
;     (LOOP MCCLIM-RENDER-INTERNALS::FOR MCCLIM-RENDER-INTERNALS::IX MCCLIM-RENDER-INTERNALS::FROM MCCLIM-RENDER-INTERNALS::START-X MCCLIM-RENDER-INTERNALS::BELOW MCCLIM-RENDER-INTERNALS::END-X
;           DO (FUNCALL FUNCTION MCCLIM-RENDER-INTERNALS::IX
;                       MCCLIM-RENDER-INTERNALS::Y MCCLIM-RENDER-INTERNALS::ALPHA))
; --> BLOCK LET 
; ==>
;   MCCLIM-RENDER-INTERNALS::START-X
; 
; note: deleting unreachable code

; --> BLOCK LET TAGBODY WHEN IF >= 
; ==>
;   MCCLIM-RENDER-INTERNALS::IX
; 
; note: deleting unreachable code

;     (FUNCALL FUNCTION MCCLIM-RENDER-INTERNALS::IX MCCLIM-RENDER-INTERNALS::Y
;              MCCLIM-RENDER-INTERNALS::ALPHA)
; --> SB-C::%FUNCALL THE SB-KERNEL:%COERCE-CALLABLE-TO-FUN 
; ==>
;   FUNCTION
; 
; note: deleting unreachable code

;     (NET.TUXEE.AA::COMPUTE-ALPHA MCCLIM-RENDER-INTERNALS::COVER
;                                  (NET.TUXEE.AA::CELL-AREA
;                                   MCCLIM-RENDER-INTERNALS::CELL))
; --> BLOCK TRUNCATE - * 
; ==>
;   (* 512 NET.TUXEE.AA::COVER)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to associate */(* /) of constants due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

; --> BLOCK 
; ==>
;   (TRUNCATE
;    (- (* 2 NET.TUXEE.AA::+CELL-WIDTH+ NET.TUXEE.AA::COVER) NET.TUXEE.AA::AREA)
;    NET.TUXEE.AA::+ALPHA-DIVISOR+)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to convert division by 2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a REAL, not a (UNSIGNED-BYTE 64).

;     (NET.TUXEE.AA::COMPUTE-ALPHA MCCLIM-RENDER-INTERNALS::COVER 0)
; --> BLOCK TRUNCATE - * 
; ==>
;   (* 512 NET.TUXEE.AA::COVER)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to associate */(* /) of constants due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

; --> BLOCK TRUNCATE 
; ==>
;   (- (* 2 NET.TUXEE.AA::+CELL-WIDTH+ NET.TUXEE.AA::COVER) NET.TUXEE.AA::AREA)
; 
; note: unable to fold zero arg due to type uncertainty: The first argument is a NUMBER, not a (OR RATIONAL (COMPLEX RATIONAL)).

; --> BLOCK 
; ==>
;   (TRUNCATE
;    (- (* 2 NET.TUXEE.AA::+CELL-WIDTH+ NET.TUXEE.AA::COVER) NET.TUXEE.AA::AREA)
;    NET.TUXEE.AA::+ALPHA-DIVISOR+)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to convert division by 2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a REAL, not a (UNSIGNED-BYTE 64).

;     (MAX MCCLIM-RENDER-INTERNALS::START (1+ MCCLIM-RENDER-INTERNALS::LAST-X))
; --> LET LET IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

; --> LET LET IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (MIN MCCLIM-RENDER-INTERNALS::END MCCLIM-RENDER-INTERNALS::X)
; --> LET LET IF <= OR LET < IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

; --> LET LET IF <= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (MIN MCCLIM-RENDER-INTERNALS::X-MIN MCCLIM-RENDER-INTERNALS::START-X)
; --> LET LET IF <= OR LET < IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.

; --> LET LET IF <= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

;     (MAX MCCLIM-RENDER-INTERNALS::X-MAX MCCLIM-RENDER-INTERNALS::END-X)
; --> LET LET IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.

; --> LET LET IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

;     (>= MCCLIM-RENDER-INTERNALS::X MCCLIM-RENDER-INTERNALS::END)
; --> OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (< (NET.TUXEE.AA::CELL-X (CAR MCCLIM-RENDER-INTERNALS::CELLS))
;        MCCLIM-RENDER-INTERNALS::START)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

;     (INCF MCCLIM-RENDER-INTERNALS::COVER
;           (NET.TUXEE.AA::CELL-COVER (CAR MCCLIM-RENDER-INTERNALS::CELLS)))
; --> SETQ THE 
; ==>
;   (+ (NET.TUXEE.AA::CELL-COVER (CAR MCCLIM-RENDER-INTERNALS::CELLS))
;      MCCLIM-RENDER-INTERNALS::COVER)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (1+ MCCLIM-RENDER-INTERNALS::LAST-X)
; ==>
;   (+ MCCLIM-RENDER-INTERNALS::LAST-X 1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (> MCCLIM-RENDER-INTERNALS::X (1+ MCCLIM-RENDER-INTERNALS::LAST-X))
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.

;     (NET.TUXEE.AA::COMPUTE-ALPHA MCCLIM-RENDER-INTERNALS::COVER 0)
; --> BLOCK TRUNCATE - * 
; ==>
;   (* 512 NET.TUXEE.AA::COVER)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; --> BLOCK TRUNCATE 
; ==>
;   (- (* 2 NET.TUXEE.AA::+CELL-WIDTH+ NET.TUXEE.AA::COVER) NET.TUXEE.AA::AREA)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (1+ MCCLIM-RENDER-INTERNALS::LAST-X)
; ==>
;   (+ MCCLIM-RENDER-INTERNALS::LAST-X 1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (MAX MCCLIM-RENDER-INTERNALS::START (1+ MCCLIM-RENDER-INTERNALS::LAST-X))
; --> LET LET IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.

;     (MIN MCCLIM-RENDER-INTERNALS::END MCCLIM-RENDER-INTERNALS::X)
; --> LET LET IF <= OR LET < IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.

;     (MIN MCCLIM-RENDER-INTERNALS::X-MIN MCCLIM-RENDER-INTERNALS::START-X)
; --> LET LET IF <= OR LET < IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

; --> LET LET IF <= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.

;     (MAX MCCLIM-RENDER-INTERNALS::X-MAX MCCLIM-RENDER-INTERNALS::END-X)
; --> LET LET IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

; --> LET LET IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.

;     (>= MCCLIM-RENDER-INTERNALS::X MCCLIM-RENDER-INTERNALS::END)
; --> OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

;     (INCF MCCLIM-RENDER-INTERNALS::COVER
;           (NET.TUXEE.AA::CELL-COVER MCCLIM-RENDER-INTERNALS::CELL))
; --> SETQ THE 
; ==>
;   (+ (NET.TUXEE.AA::CELL-COVER MCCLIM-RENDER-INTERNALS::CELL)
;      MCCLIM-RENDER-INTERNALS::COVER)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (NET.TUXEE.AA::COMPUTE-ALPHA MCCLIM-RENDER-INTERNALS::COVER
;                                  (NET.TUXEE.AA::CELL-AREA
;                                   MCCLIM-RENDER-INTERNALS::CELL))
; --> BLOCK TRUNCATE - * 
; ==>
;   (* 512 NET.TUXEE.AA::COVER)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; --> BLOCK TRUNCATE 
; ==>
;   (- (* 2 NET.TUXEE.AA::+CELL-WIDTH+ NET.TUXEE.AA::COVER) NET.TUXEE.AA::AREA)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Extensions/render/backend/fonts.lisp
; in: DEFMETHOD TEXT-SIZE (RENDER-MEDIUM-MIXIN T)
;     (MAX MCCLIM-RENDER-INTERNALS::W MCCLIM-RENDER-INTERNALS::WIDTH)
; --> LET LET IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

; --> LET LET IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.

;     (+ MCCLIM-RENDER-INTERNALS::ASCENT MCCLIM-RENDER-INTERNALS::DESCENT)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (MAX MCCLIM-RENDER-INTERNALS::W MCCLIM-RENDER-INTERNALS::WIDTH)
; --> LET LET IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

; --> LET LET IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.

;     (+ MCCLIM-RENDER-INTERNALS::ASCENT MCCLIM-RENDER-INTERNALS::DESCENT
;        MCCLIM-RENDER-INTERNALS::H)
; --> + 
; ==>
;   (+ MCCLIM-RENDER-INTERNALS::ASCENT MCCLIM-RENDER-INTERNALS::DESCENT)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; ==>
;   (+ (+ MCCLIM-RENDER-INTERNALS::ASCENT MCCLIM-RENDER-INTERNALS::DESCENT)
;      MCCLIM-RENDER-INTERNALS::H)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (+ MCCLIM-RENDER-INTERNALS::ASCENT MCCLIM-RENDER-INTERNALS::DESCENT
;        MCCLIM-RENDER-INTERNALS::Y)
; --> + 
; ==>
;   (+ MCCLIM-RENDER-INTERNALS::ASCENT MCCLIM-RENDER-INTERNALS::DESCENT)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; ==>
;   (+ (+ MCCLIM-RENDER-INTERNALS::ASCENT MCCLIM-RENDER-INTERNALS::DESCENT)
;      MCCLIM-RENDER-INTERNALS::Y)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (+ MCCLIM-RENDER-INTERNALS::ASCENT MCCLIM-RENDER-INTERNALS::DESCENT
;        MCCLIM-RENDER-INTERNALS::BASELINE)
; --> + 
; ==>
;   (+ MCCLIM-RENDER-INTERNALS::ASCENT MCCLIM-RENDER-INTERNALS::DESCENT)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; ==>
;   (+ (+ MCCLIM-RENDER-INTERNALS::ASCENT MCCLIM-RENDER-INTERNALS::DESCENT)
;      MCCLIM-RENDER-INTERNALS::BASELINE)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Extensions/bezier/mcclim-bezier.asd" contains definition for system "mcclim-bezier-core". Please only define "mcclim-bezier" and secondary systems with a name starting with "mcclim-bezier/" (e.g. "mcclim-bezier/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Extensions/bezier/mcclim-bezier.asd" contains definition for system "mcclim-bezier-clx". Please only define "mcclim-bezier" and secondary systems with a name starting with "mcclim-bezier/" (e.g. "mcclim-bezier/test") in that file.
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "mcclim-bezier-core" "bezier"), but dependency (ASDF/LISP-ACTION:LOAD-OP "mcclim-bezier-core" "package") wasn't done yet!
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Extensions/bezier/mcclim-bezier.asd" contains definition for system "mcclim-bezier-core". Please only define "mcclim-bezier" and secondary systems with a name starting with "mcclim-bezier/" (e.g. "mcclim-bezier/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Extensions/bezier/mcclim-bezier.asd" contains definition for system "mcclim-bezier-clx". Please only define "mcclim-bezier" and secondary systems with a name starting with "mcclim-bezier/" (e.g. "mcclim-bezier/test") in that file.
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "mcclim-bezier-clx"), but dependency (ASDF/LISP-ACTION:LOAD-OP "mcclim-bezier-core") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "mcclim-bezier"), but dependency (ASDF/LISP-ACTION:LOAD-OP "mcclim-bezier-core") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "mcclim-bezier"), but dependency (ASDF/FIND-SYSTEM:DEFINE-OP "mcclim-bezier") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:COMPILE-OP "mcclim-bezier"), but dependency (ASDF/FIND-SYSTEM:DEFINE-OP "mcclim-bezier") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:LOAD-OP "mcclim-bezier"), but dependency (ASDF/FIND-SYSTEM:DEFINE-OP "mcclim-bezier") wasn't done yet!

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Apps/Listener/file-types.lisp
; in: DEFUN TRANSLATE-URI-PATHNAME-DIRECTORY
;     (WARN "Don't know how to convert ~A to a URI." PATHNAME)
; ==>
;   "Don't know how to convert ~A to a URI."
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Apps/Listener/asdf.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-LISTENER::OBJECT
;                                       (TYPE CLIM-LISTENER::ASDF-SYSTEM))
;                                      (TYPEP CLIM-LISTENER::OBJECT
;                                             'ASDF/SYSTEM:SYSTEM))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM-LISTENER::ASDF-SYSTEM)|)
;                                 CLIM-LISTENER::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM-LISTENER::ASDF-SYSTEM)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Apps/Listener/asdf.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-LISTENER::OBJECT
;                                       (TYPE CLIM-LISTENER::ASDF-SYSTEM) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       CLIM-LISTENER::ACCEPTABLY)
;                                      (IF CLIM-LISTENER::ACCEPTABLY
;                                          (PRINC
;                                           (CLIM-LISTENER::ASDF-SYSTEM-NAME
;                                            CLIM-LISTENER::OBJECT)
;                                           STREAM)
;                                          (LET* ((CLIM-LISTENER::HISTORY #)
;                                                 (CLIM-LISTENER::LOADED-P #)
;                                                 (CLIM-LISTENER::EFF-HISTORY #))
;                                            (WHEN (AND # #)
;                                              (PUSH :UNLOADED
;                                                    CLIM-LISTENER::EFF-HISTORY))
;                                            (FORMAT STREAM "~A~A"
;                                                    (CLIM-LISTENER::ASDF-SYSTEM-NAME
;                                                     CLIM-LISTENER::OBJECT)
;                                                    (IF #
;                                                        #
;                                                        #)))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM-LISTENER::ASDF-SYSTEM)|)
;                                 CLIM-LISTENER::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 CLIM-LISTENER::ACCEPTABLY)
;                                ((BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM-LISTENER::ASDF-SYSTEM)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Apps/Listener/asdf.lisp
; in: DEFINE-PRESENTATION-METHOD ACCEPT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:ACCEPT
;                                      ((TYPE CLIM-LISTENER::ASDF-SYSTEM) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                      (MULTIPLE-VALUE-BIND
;                                          (CLIM-LISTENER::OBJECT
;                                           CLIM-LISTENER::SUCCESS)
;                                          (CLIM:COMPLETING-FROM-SUGGESTIONS (STREAM)
;                                            (DOLIST (CLIM-LISTENER::SYSTEM #)
;                                              (CLIM:SUGGEST #
;                                                            CLIM-LISTENER::SYSTEM)))
;                                        (IF CLIM-LISTENER::SUCCESS
;                                            CLIM-LISTENER::OBJECT
;                                            (CLIM:SIMPLE-PARSE-ERROR
;                                             "Unknown system"))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%ACCEPT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM-LISTENER::ASDF-SYSTEM)|)
;                                 TYPE STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                ((BLOCK CLIM:ACCEPT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM-LISTENER::ASDF-SYSTEM)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "clim-listener" "asdf">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Apps/Listener/dev-commands.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-LISTENER::OBJECT
;                                       (TYPE GENERIC-FUNCTION))
;                                      (TYPEP CLIM-LISTENER::OBJECT
;                                             'GENERIC-FUNCTION))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::GENERIC-FUNCTION)|)
;                                 CLIM-LISTENER::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::GENERIC-FUNCTION)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Apps/Listener/dev-commands.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-LISTENER::OBJECT (TYPE PACKAGE))
;                                      (TYPEP CLIM-LISTENER::OBJECT 'PACKAGE))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::PACKAGE)|)
;                                 CLIM-LISTENER::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::PACKAGE)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Apps/Listener/dev-commands.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-LISTENER::OBJECT (TYPE PACKAGE-NAME))
;                                      (FIND-PACKAGE CLIM-LISTENER::OBJECT))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::PACKAGE-NAME)|)
;                                 CLIM-LISTENER::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::PACKAGE-NAME)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Apps/Listener/dev-commands.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-LISTENER::OBJECT
;                                       (TYPE GENERIC-FUNCTION) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       &ALLOW-OTHER-KEYS)
;                                      (PRINC
;                                       (SB-MOP:GENERIC-FUNCTION-NAME
;                                        CLIM-LISTENER::OBJECT)
;                                       STREAM))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::GENERIC-FUNCTION)|)
;                                 CLIM-LISTENER::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 &ALLOW-OTHER-KEYS)
;                                ((BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::GENERIC-FUNCTION)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Apps/Listener/dev-commands.lisp
; in: DEFINE-PRESENTATION-METHOD ACCEPT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:ACCEPT
;                                      ((TYPE GENERIC-FUNCTION) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                      (LET ((CLIM-LISTENER::FN
;                                             (CLIM:ACCEPT 'CLIM:EXPRESSION :STREAM
;                                                          STREAM :VIEW CLIM:VIEW
;                                                          :HISTORY
;                                                          'GENERIC-FUNCTION
;                                                          :PROMPT NIL)))
;                                        (WHEN
;                                            (TYPEP CLIM-LISTENER::FN
;                                                   'GENERIC-FUNCTION)
;                                          (RETURN-FROM CLIM:ACCEPT
;                                            CLIM-LISTENER::FN))
;                                        (HANDLER-CASE
;                                         (FDEFINITION CLIM-LISTENER::FN)
;                                         (ERROR NIL
;                                                (CLIM:SIMPLE-PARSE-ERROR
;                                                 "~S is not the name of a generic function."
;                                                 CLIM-LISTENER::FN)))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%ACCEPT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::GENERIC-FUNCTION)|)
;                                 TYPE STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                ((BLOCK CLIM:ACCEPT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::GENERIC-FUNCTION)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Apps/Listener/dev-commands.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-LISTENER::OBJECT
;                                       (TYPE CLIM-LISTENER::BYTES) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                       &ALLOW-OTHER-KEYS)
;                                      (IF (ZEROP CLIM-LISTENER::OBJECT)
;                                          (PRINC "0" STREAM)
;                                          (LET* ((CLIM-LISTENER::SUFFIXES '#)
;                                                 (CLIM-LISTENER::X #)
;                                                 (CLIM-LISTENER::IDX #))
;                                            (IF (ZEROP CLIM-LISTENER::IDX)
;                                                (FORMAT STREAM "~A bytes"
;                                                        CLIM-LISTENER::OBJECT)
;                                                (FORMAT STREAM "~,1F~A" # #)))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM-LISTENER::BYTES)|)
;                                 CLIM-LISTENER::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY
;                                 &ALLOW-OTHER-KEYS)
;                                ((BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM-LISTENER::BYTES)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Apps/Listener/dev-commands.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENTATION-TYPEP
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENTATION-TYPEP
;                                      (CLIM-LISTENER::OBJECT (TYPE PACKAGE))
;                                      (PACKAGEP CLIM-LISTENER::OBJECT))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENTATION-TYPEP NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::PACKAGE)|)
;                                 CLIM-LISTENER::OBJECT TYPE)
;                                ((BLOCK CLIM:PRESENTATION-TYPEP
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::PACKAGE)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Apps/Listener/dev-commands.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-LISTENER::OBJECT (TYPE PACKAGE) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                      (PRINC (PACKAGE-NAME CLIM-LISTENER::OBJECT)
;                                             STREAM))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::PACKAGE)|)
;                                 CLIM-LISTENER::OBJECT TYPE STREAM
;                                 (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                ((BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::PACKAGE)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Apps/Listener/dev-commands.lisp
; in: DEFINE-PRESENTATION-METHOD ACCEPT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:ACCEPT
;                                      ((TYPE PACKAGE) STREAM
;                                       (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                      (MULTIPLE-VALUE-BIND
;                                          (CLIM-LISTENER::OBJECT
;                                           CLIM-LISTENER::SUCCESS)
;                                          (CLIM:COMPLETING-FROM-SUGGESTIONS (STREAM)
;                                            (LOOP CLIM-LISTENER::FOR CLIM-LISTENER::P CLIM-LISTENER::IN (LIST-ALL-PACKAGES)
;                                                  DO (PROGN # #)))
;                                        (IF CLIM-LISTENER::SUCCESS
;                                            CLIM-LISTENER::OBJECT
;                                            (CLIM:SIMPLE-PARSE-ERROR
;                                             "No package"))))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%ACCEPT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type COMMON-LISP::PACKAGE)|)
;                                 TYPE STREAM (CLIM:VIEW CLIM:TEXTUAL-VIEW) &KEY)
;                                ((BLOCK CLIM:ACCEPT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type COMMON-LISP::PACKAGE)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "clim-listener" "dev-commands">
WARNING: redefining CLIM-LISTENER::MIME-TYPE-TO-COMMAND in DEFGENERIC

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/mcclim/01746b8668a35c036c4022757605ea6d1308ede3/mcclim-20180205-git/Apps/Listener/listener.lisp
; in: DEFINE-PRESENTATION-METHOD PRESENT
;     (CLIM:DEFINE-PRESENTATION-METHOD CLIM:PRESENT
;                                      (CLIM-LISTENER::OBJECT
;                                       (TYPE CLIM-LISTENER::EMPTY-INPUT) STREAM
;                                       CLIM:VIEW &KEY &ALLOW-OTHER-KEYS)
;                                      (PRINC "" STREAM))
; --> DEFMETHOD PROGN EVAL-WHEN 
; ==>
;   (SB-PCL::%DEFMETHOD-EXPANDER CLIM-INTERNALS::%PRESENT NIL
;                                ((CLIM-INTERNALS::TYPE-KEY
;                                  CLIM-INTERNALS::|(presentation-type CLIM-LISTENER::EMPTY-INPUT)|)
;                                 CLIM-LISTENER::OBJECT TYPE STREAM CLIM:VIEW
;                                 &KEY &ALLOW-OTHER-KEYS)
;                                ((BLOCK CLIM:PRESENT
;                                   (LET (#)
;                                     (LET #
;                                       #
;                                       #)))))
; 
; caught STYLE-WARNING:
;   Cannot find type for specializer CLIM-INTERNALS::|(presentation-type CLIM-LISTENER::EMPTY-INPUT)| when executing SB-PCL:SPECIALIZER-TYPE-SPECIFIER for a STANDARD-METHOD of a CLIM-INTERNALS::PRESENTATION-GENERIC-FUNCTION.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "clim-listener" "listener">
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-xml". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-dom". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-klacks". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-test". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-xml" "util"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml" "package") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-xml" "xml-name-rune-p"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml" "package") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-xml" "xml-name-rune-p"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml" "util") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-xml" "split-sequence"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml" "package") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-xml" "xml-parse"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml" "package") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-xml" "xml-parse"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml" "util") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-xml" "xml-parse"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml" "sax-handler") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-xml" "xml-parse"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml" "split-sequence") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-xml" "xml-parse"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml" "xml-name-rune-p") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-xml" "unparse"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml" "xml-parse") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-xml" "xmls-compat"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml" "xml-parse") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-xml" "recoder"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml" "xml-parse") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-xml" "xmlns-normalizer"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml" "xml-parse") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-xml" "space-normalizer"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml" "xml-parse") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-xml" "catalog"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml" "xml-parse") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-xml" "sax-proxy"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml" "xml-parse") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-xml" "atdoc-configuration"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml" "package") wasn't done yet!
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-xml". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-dom". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-klacks". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-test". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-dom"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-dom" "rune-impl"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-dom" "package") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-dom" "rune-builder"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-dom" "rune-impl") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-dom" "dom-sax"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-dom" "package") wasn't done yet!
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-xml". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-dom". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-klacks". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-test". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-klacks"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-klacks" "klacks"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-klacks" "package") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-klacks" "klacks-impl"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-klacks" "klacks") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-klacks" "tap-source"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-klacks" "klacks-impl") wasn't done yet!
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-xml". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-dom". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-klacks". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cxml/833a30fefae72cc146d4cd2135bf8e09f8705908/cxml-20180205-git/cxml.asd" contains definition for system "cxml-test". Please only define "cxml" and secondary systems with a name starting with "cxml/" (e.g. "cxml/test") in that file.
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-test"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-xml") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-test"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-klacks") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml-test"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-dom") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-dom") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml"), but dependency (ASDF/LISP-ACTION:LOAD-OP "cxml-klacks") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "cxml"), but dependency (ASDF/FIND-SYSTEM:DEFINE-OP "cxml") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:COMPILE-OP "cxml"), but dependency (ASDF/FIND-SYSTEM:DEFINE-OP "cxml") wasn't done yet!
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:LOAD-OP "cxml"), but dependency (ASDF/FIND-SYSTEM:DEFINE-OP "cxml") wasn't done yet!
Unhandled SB-KERNEL:SIMPLE-PACKAGE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING {10006105B3}>: The name "CLIM-MOP" does not designate any package.

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {10006105B3}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<SB-KERNEL:SIMPLE-PACKAGE-ERROR "The name ~S does not designate any package." {100B984FB3}> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* #<SB-KERNEL:SIMPLE-PACKAGE-ERROR "The name ~S does not designate any package." {100B984FB3}>)
2: (INVOKE-DEBUGGER #<SB-KERNEL:SIMPLE-PACKAGE-ERROR "The name ~S does not designate any package." {100B984FB3}>)
3: (ERROR SB-KERNEL:SIMPLE-PACKAGE-ERROR :PACKAGE "CLIM-MOP" :FORMAT-CONTROL "The name ~S does not designate any package." :FORMAT-ARGUMENTS ("CLIM-MOP"))
4: (SB-INT:FIND-UNDELETED-PACKAGE-OR-LOSE "CLIM-MOP")
5: (SB-IMPL::USE-LIST-PACKAGES NIL ("CLIM-LISP" "CLIM-MOP"))
6: ((FLET SB-IMPL::THUNK :IN SB-IMPL::%DEFPACKAGE))
7: ((FLET "WITHOUT-INTERRUPTS-BODY-29" :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
8: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SB-IMPL::CALL-WITH-PACKAGE-GRAPH) {7FFFF6DA5D2B}> #<SB-THREAD:MUTEX "Package Graph Lock" owner: #<SB-THREAD:THREAD "main thread" RUNNING {10006105B3}>> T NIL)
9: (SB-IMPL::CALL-WITH-PACKAGE-GRAPH #<CLOSURE (FLET SB-IMPL::THUNK :IN SB-IMPL::%DEFPACKAGE) {7FFFF6DA5D6B}>)
10: (SB-IMPL::%DEFPACKAGE "GSHARP-UTILITIES" NIL NIL ("BUILT-IN-CLASS") NIL ("CLIM-LISP" "CLIM-MOP") NIL NIL ("NINSERT-ELEMENT" "DEFINE-STEALTH-MIXIN" "UNICODE-TO-CHAR" "CHAR-TO-UNICODE") ("GSHARP-UTILITIES") NIL NIL #S(SB-C:DEFINITION-SOURCE-LOCATION :NAMESTRING "/home/quicklisp/quicklisp-controller/dist/build-cache/gsharp/39c73ce71ba0ca6edce788fd1da322e39336b3a9/gsharp-20180205-git/packages.lisp" :INDICES 32769) NIL)
11: (SB-INT:SIMPLE-EVAL-IN-LEXENV (SB-IMPL::%DEFPACKAGE #1="GSHARP-UTILITIES" (QUOTE NIL) (QUOTE NIL) (QUOTE ("BUILT-IN-CLASS")) (QUOTE NIL) (QUOTE ("CLIM-LISP" "CLIM-MOP")) (QUOTE NIL) (QUOTE NIL) (QUOTE ("NINSERT-ELEMENT" "DEFINE-STEALTH-MIXIN" "UNICODE-TO-CHAR" "CHAR-TO-UNICODE")) (QUOTE (#1#)) (QUOTE NIL) ...) #<NULL-LEXENV>)
12: (SB-INT:SIMPLE-EVAL-IN-LEXENV (PROGN (SB-IMPL::%DEFPACKAGE #1="GSHARP-UTILITIES" (QUOTE NIL) (QUOTE NIL) (QUOTE ("BUILT-IN-CLASS")) (QUOTE NIL) (QUOTE ("CLIM-LISP" "CLIM-MOP")) (QUOTE NIL) (QUOTE NIL) (QUOTE ("NINSERT-ELEMENT" "DEFINE-STEALTH-MIXIN" "UNICODE-TO-CHAR" "CHAR-TO-UNICODE")) (QUOTE (#1#)) (QUOTE NIL) ...)) #<NULL-LEXENV>)
13: (EVAL-TLF (PROGN (SB-IMPL::%DEFPACKAGE #1="GSHARP-UTILITIES" (QUOTE NIL) (QUOTE NIL) (QUOTE ("BUILT-IN-CLASS")) (QUOTE NIL) (QUOTE ("CLIM-LISP" "CLIM-MOP")) (QUOTE NIL) (QUOTE NIL) (QUOTE ("NINSERT-ELEMENT" "DEFINE-STEALTH-MIXIN" "UNICODE-TO-CHAR" "CHAR-TO-UNICODE")) (QUOTE (#1#)) (QUOTE NIL) ...)) 0 #<NULL-LEXENV>)
14: ((FLET SB-C::FROB :IN SB-C::EVAL-COMPILE-TOPLEVEL))
15: ((FLET SB-C::DEFAULT-PROCESSOR :IN SB-C::PROCESS-TOPLEVEL-FORM) (SB-IMPL::%DEFPACKAGE #1="GSHARP-UTILITIES" (QUOTE NIL) (QUOTE NIL) (QUOTE ("BUILT-IN-CLASS")) (QUOTE NIL) (QUOTE ("CLIM-LISP" "CLIM-MOP")) (QUOTE NIL) (QUOTE NIL) (QUOTE ("NINSERT-ELEMENT" "DEFINE-STEALTH-MIXIN" "UNICODE-TO-CHAR" "CHAR-TO-UNICODE")) (QUOTE (#1#)) (QUOTE NIL) ...))
16: (SB-C::PROCESS-TOPLEVEL-FORM (SB-IMPL::%DEFPACKAGE #1="GSHARP-UTILITIES" (QUOTE NIL) (QUOTE NIL) (QUOTE ("BUILT-IN-CLASS")) (QUOTE NIL) (QUOTE ("CLIM-LISP" "CLIM-MOP")) (QUOTE NIL) (QUOTE NIL) (QUOTE ("NINSERT-ELEMENT" "DEFINE-STEALTH-MIXIN" "UNICODE-TO-CHAR" "CHAR-TO-UNICODE")) (QUOTE (#1#)) (QUOTE NIL) ...) ((EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (SB-IMPL::%DEFPACKAGE #1="GSHARP-UTILITIES" (QUOTE NIL) (QUOTE NIL) (QUOTE ("BUILT-IN-CLASS")) (QUOTE NIL) (QUOTE ("CLIM-LISP" "CLIM-MOP")) (QUOTE NIL) (QUOTE NIL) (QUOTE ("NINSERT-ELEMENT" "DEFINE-STEALTH-MIXIN" "UNICODE-TO-CHAR" "CHAR-TO-UNICODE")) (QUOTE (#1#)) (QUOTE NIL) ...)) SB-C::ORIGINAL-SOURCE-START 0 0) (:COMPILE-TOPLEVEL))
17: (SB-C::PROCESS-TOPLEVEL-PROGN ((SB-IMPL::%DEFPACKAGE #1="GSHARP-UTILITIES" (QUOTE NIL) (QUOTE NIL) (QUOTE ("BUILT-IN-CLASS")) (QUOTE NIL) (QUOTE ("CLIM-LISP" "CLIM-MOP")) (QUOTE NIL) (QUOTE NIL) (QUOTE ("NINSERT-ELEMENT" "DEFINE-STEALTH-MIXIN" "UNICODE-TO-CHAR" "CHAR-TO-UNICODE")) (QUOTE (#1#)) (QUOTE NIL) ...)) ((EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (SB-IMPL::%DEFPACKAGE #1="GSHARP-UTILITIES" (QUOTE NIL) (QUOTE NIL) (QUOTE ("BUILT-IN-CLASS")) (QUOTE NIL) (QUOTE ("CLIM-LISP" "CLIM-MOP")) (QUOTE NIL) (QUOTE NIL) (QUOTE ("NINSERT-ELEMENT" "DEFINE-STEALTH-MIXIN" "UNICODE-TO-CHAR" "CHAR-TO-UNICODE")) (QUOTE (#1#)) (QUOTE NIL) ...)) SB-C::ORIGINAL-SOURCE-START 0 0) (:COMPILE-TOPLEVEL))
18: (SB-C::PROCESS-TOPLEVEL-FORM (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (SB-IMPL::%DEFPACKAGE #1="GSHARP-UTILITIES" (QUOTE NIL) (QUOTE NIL) (QUOTE ("BUILT-IN-CLASS")) (QUOTE NIL) (QUOTE ("CLIM-LISP" "CLIM-MOP")) (QUOTE NIL) (QUOTE NIL) (QUOTE ("NINSERT-ELEMENT" "DEFINE-STEALTH-MIXIN" "UNICODE-TO-CHAR" "CHAR-TO-UNICODE")) (QUOTE (#1#)) (QUOTE NIL) ...)) (SB-C::ORIGINAL-SOURCE-START 0 0) NIL)
19: ((FLET SB-C::DEFAULT-PROCESSOR :IN SB-C::PROCESS-TOPLEVEL-FORM) (DEFPACKAGE :GSHARP-UTILITIES (:SHADOW BUILT-IN-CLASS) (:USE :CLIM-LISP :CLIM-MOP) (:EXPORT #:NINSERT-ELEMENT #:DEFINE-STEALTH-MIXIN #:UNICODE-TO-CHAR #:CHAR-TO-UNICODE)))
20: (SB-C::PROCESS-TOPLEVEL-FORM (DEFPACKAGE :GSHARP-UTILITIES (:SHADOW BUILT-IN-CLASS) (:USE :CLIM-LISP :CLIM-MOP) (:EXPORT #:NINSERT-ELEMENT #:DEFINE-STEALTH-MIXIN #:UNICODE-TO-CHAR #:CHAR-TO-UNICODE)) (SB-C::ORIGINAL-SOURCE-START 0 0) NIL)
21: ((LAMBDA (SB-KERNEL:FORM &KEY :CURRENT-INDEX &ALLOW-OTHER-KEYS) :IN SB-C::SUB-SUB-COMPILE-FILE) (DEFPACKAGE :GSHARP-UTILITIES (:SHADOW BUILT-IN-CLASS) (:USE :CLIM-LISP :CLIM-MOP) (:EXPORT #:NINSERT-ELEMENT #:DEFINE-STEALTH-MIXIN #:UNICODE-TO-CHAR #:CHAR-TO-UNICODE)) :CURRENT-INDEX 0)
22: (SB-C::%DO-FORMS-FROM-INFO #<FUNCTION (LAMBDA (SB-KERNEL:FORM &KEY :CURRENT-INDEX &ALLOW-OTHER-KEYS) :IN SB-C::SUB-SUB-COMPILE-FILE) {22248C2B}> #<SB-C::SOURCE-INFO {100B979AE3}> SB-C::INPUT-ERROR-IN-COMPILE-FILE)
23: (SB-C::SUB-SUB-COMPILE-FILE #<SB-C::SOURCE-INFO {100B979AE3}>)
24: ((FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SB-C::SUB-COMPILE-FILE))
25: ((FLET "WITHOUT-INTERRUPTS-BODY-29" :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
26: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SB-C::SUB-COMPILE-FILE) {7FFFF6DA66DB}> #<SB-THREAD:MUTEX "World Lock" owner: #<SB-THREAD:THREAD "main thread" RUNNING {10006105B3}>> T NIL)
27: ((LAMBDA NIL :IN SB-C::SUB-COMPILE-FILE))
28: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
29: (SB-C::SUB-COMPILE-FILE #<SB-C::SOURCE-INFO {100B979AE3}>)
30: (COMPILE-FILE #P"/home/quicklisp/quicklisp-controller/dist/build-cache/gsharp/39c73ce71ba0ca6edce788fd1da322e39336b3a9/gsharp-20180205-git/packages.lisp" :OUTPUT-FILE #P#<(SIMPLE-ARRAY CHARACTER (202)) /home/quicklisp/.cache/common-lisp/sbcl-1.4.4-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/gsharp/39c73ce71ba0ca6edce788fd1da322e39336b3a9/gsharp-20180205-git/packages-tmpP7RRFRW4.fa... {100B9DF3BF}> :VERBOSE NIL :PRINT NIL :EXTERNAL-FORMAT :UTF-8 :TRACE-FILE NIL :BLOCK-COMPILE NIL :EMIT-CFASL NIL)
31: (UIOP/UTILITY:CALL-WITH-MUFFLED-CONDITIONS #<CLOSURE (LAMBDA NIL :IN UIOP/LISP-BUILD:COMPILE-FILE*) {100B97704B}> NIL)
32: (UIOP/PATHNAME:CALL-WITH-ENOUGH-PATHNAME #P"/home/quicklisp/quicklisp-controller/dist/build-cache/gsharp/39c73ce71ba0ca6edce788fd1da322e39336b3a9/gsharp-20180205-git/packages.lisp" NIL #<CLOSURE (LAMBDA (UIOP/LISP-BUILD::INPUT-FILE) :IN UIOP/LISP-BUILD:COMPILE-FILE*) {100B97695B}>)
33: (UIOP/LISP-BUILD:COMPILE-FILE* #P"/home/quicklisp/quicklisp-controller/dist/build-cache/gsharp/39c73ce71ba0ca6edce788fd1da322e39336b3a9/gsharp-20180205-git/packages.lisp" :OUTPUT-FILE #P"/home/quicklisp/.cache/common-lisp/sbcl-1.4.4-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/gsharp/39c73ce71ba0ca6edce788fd1da322e39336b3a9/gsharp-20180205-git/packages.fasl" :EXTERNAL-FORMAT :UTF-8 :WARNINGS-FILE NIL)
34: (ASDF/LISP-ACTION:PERFORM-LISP-COMPILATION #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "gsharp" "packages">)
35: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "gsharp" "packages">)
36: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
37: ((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS :AROUND (T T)) #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "gsharp" "packages">) [fast-method]
38: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1005B01283}>) [fast-method]
39: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
40: ((:METHOD ASDF/PLAN:PERFORM-PLAN :AROUND (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1005B01283}>) [fast-method]
41: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "gsharp"> :PLAN-CLASS NIL :PLAN-OPTIONS NIL) [fast-method]
42: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "gsharp">)
43: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
44: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "gsharp">) [fast-method]
45: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "gsharp")
46: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
47: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "gsharp") [fast-method]
48: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {1005AF967B}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
49: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
50: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {1005AB6ACB}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
51: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "gsharp") [fast-method]
52: (DEPCHECK::COMPUTE-DEPENDENCIES "gsharp" "gsharp")
53: (DEPCHECK::MAGIC "gsharp" "gsharp" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-GF0NlZjT/depcheck-win.txt")
54: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "gsharp" "gsharp" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-GF0NlZjT/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-GF0NlZjT/depcheck-fail.txt"))
55: ((LAMBDA NIL :IN "/home/quicklisp/src/quicklisp-controller/dumper-2SKVI5f7.lisp"))
56: ((FLET SB-UNIX::BODY :IN SAVE-LISP-AND-DIE))
57: ((FLET "WITHOUT-INTERRUPTS-BODY-36" :IN SAVE-LISP-AND-DIE))
58: ((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 90 STYLE-WARNING conditions
;   printed 582 notes