cl-garnet

SBCL 1.4.3 / ASDF 3.3.1

org.xoanonos.gui.garnet

WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-fad/c651a53bfe4663b51bce20ffdc29f380f4c70408/cl-fad-20180125-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/cl-ppcre/3d57f1e446e4894097acebf36d52978ddaa62531/cl-ppcre-20180125-git/cl-ppcre.asd" contains definition for system "cl-ppcre-test". Please only define "cl-ppcre" and secondary systems with a name starting with "cl-ppcre/" (e.g. "cl-ppcre/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-store/87e05028f4ced6f4d2864ce7e790f5f249ffaa9a/cl-store-20180125-git/cl-store.asd" contains definition for system "cl-store-tests". Please only define "cl-store" and secondary systems with a name starting with "cl-store/" (e.g. "cl-store/test") in that file.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-vectors/55f19b15187b1a1026c7fd139fedf3cb7663847b/cl-vectors-20180125-git/aa-misc.lisp
; in: DEFUN IMAGE-PUT-PIXEL
;     (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y NET.TUXEE.AA-MISC::X
;           NET.TUXEE.AA-MISC::RGB)
; --> 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.

;     (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
; ==>
;   (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.

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

;     (NET.TUXEE.AA-MISC::BLEND-VALUE
;      (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y NET.TUXEE.AA-MISC::X
;            NET.TUXEE.AA-MISC::RGB)
;      (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
;      (FUNCALL NET.TUXEE.AA-MISC::ALPHA-FUNCTION NET.TUXEE.AA-MISC::ALPHA))
; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR + 
; ==>
;   (* (- 256 NET.TUXEE.AA-MISC::ALPHA) NET.TUXEE.AA-MISC::A)
; 
; 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.

; ==>
;   (* NET.TUXEE.AA-MISC::ALPHA NET.TUXEE.AA-MISC::B)
; 
; 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.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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).

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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.

;     (<= 0 NET.TUXEE.AA-MISC::Y (1- NET.TUXEE.AA-MISC::HEIGHT))
; --> 
; --> (LAMBDA (#:G13 #:G12 #:G11) (DECLARE (TYPE REAL #:G13 #:G12 #:G11)) (IF (<= #:G13 #:G12) (IF (<= #:G12 #:G11) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF <= >= 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.

; --> 
; --> (LAMBDA (#:G13 #:G12 #:G11) (DECLARE (TYPE REAL #:G13 #:G12 #:G11)) (IF (<= #:G13 #:G12) (IF (<= #:G12 #:G11) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF <= >= 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.

;     (NET.TUXEE.AA-MISC::BLEND-VALUE
;      (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y NET.TUXEE.AA-MISC::X
;            NET.TUXEE.AA-MISC::RGB)
;      (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
;      (FUNCALL NET.TUXEE.AA-MISC::ALPHA-FUNCTION NET.TUXEE.AA-MISC::ALPHA))
; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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.

;     (SETF (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y
;                 NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::RGB)
;             (NET.TUXEE.AA-MISC::BLEND-VALUE
;              (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y
;                    NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::RGB)
;              (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
;              (FUNCALL NET.TUXEE.AA-MISC::ALPHA-FUNCTION
;                       NET.TUXEE.AA-MISC::ALPHA)))
; --> 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.

;     (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y NET.TUXEE.AA-MISC::X
;           NET.TUXEE.AA-MISC::RGB)
; --> 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.

;     (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
; ==>
;   (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.

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

;     (* NET.TUXEE.AA-MISC::OPACITY
;        (FUNCALL NET.TUXEE.AA-MISC::ALPHA-FUNCTION NET.TUXEE.AA-MISC::ALPHA))
; 
; 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.

;     (FLOOR
;      (* NET.TUXEE.AA-MISC::OPACITY
;         (FUNCALL NET.TUXEE.AA-MISC::ALPHA-FUNCTION NET.TUXEE.AA-MISC::ALPHA)))
; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET 
; ==>
;   (SB-KERNEL:%UNARY-TRUNCATE SB-C::X)
; 
; 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.

;     (SETF (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y
;                 NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::RGB)
;             (NET.TUXEE.AA-MISC::BLEND-VALUE
;              (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y
;                    NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::RGB)
;              (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
;              (FLOOR (* NET.TUXEE.AA-MISC::OPACITY #))))
; --> 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.

;     (FLOOR
;      (* NET.TUXEE.AA-MISC::OPACITY
;         (FUNCALL NET.TUXEE.AA-MISC::ALPHA-FUNCTION NET.TUXEE.AA-MISC::ALPHA)))
; --> FLOOR 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 (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (<= 0 NET.TUXEE.AA-MISC::X (1- NET.TUXEE.AA-MISC::WIDTH))
; --> 
; --> (LAMBDA (#:G10 #:G9 #:G8) (DECLARE (TYPE REAL #:G10 #:G9 #:G8)) (IF (<= #:G10 #:G9) (IF (<= #:G9 #:G8) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 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.

; --> 
; --> (LAMBDA (#:G10 #:G9 #:G8) (DECLARE (TYPE REAL #:G10 #:G9 #:G8)) (IF (<= #:G10 #:G9) (IF (<= #:G9 #:G8) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 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.

;     (FLOOR
;      (* NET.TUXEE.AA-MISC::OPACITY
;         (FUNCALL NET.TUXEE.AA-MISC::ALPHA-FUNCTION NET.TUXEE.AA-MISC::ALPHA)))
; --> FLOOR 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-MISC::BLEND-VALUE
;      (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y NET.TUXEE.AA-MISC::X
;            NET.TUXEE.AA-MISC::RGB)
;      (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
;      (FLOOR
;       (* NET.TUXEE.AA-MISC::OPACITY
;          (FUNCALL NET.TUXEE.AA-MISC::ALPHA-FUNCTION NET.TUXEE.AA-MISC::ALPHA))))
; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR + 
; ==>
;   (* (- 256 NET.TUXEE.AA-MISC::ALPHA) NET.TUXEE.AA-MISC::A)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The second argument is a NUMBER, not a INTEGER.

; ==>
;   (* NET.TUXEE.AA-MISC::ALPHA NET.TUXEE.AA-MISC::B)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The second argument is a NUMBER, not a INTEGER.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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).

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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.

;     (<= 0 NET.TUXEE.AA-MISC::X (1- NET.TUXEE.AA-MISC::WIDTH))
; --> 
; --> (LAMBDA (#:G10 #:G9 #:G8) (DECLARE (TYPE REAL #:G10 #:G9 #:G8)) (IF (<= #:G10 #:G9) (IF (<= #:G9 #:G8) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF <= >= 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.

; --> 
; --> (LAMBDA (#:G10 #:G9 #:G8) (DECLARE (TYPE REAL #:G10 #:G9 #:G8)) (IF (<= #:G10 #:G9) (IF (<= #:G9 #:G8) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF <= >= 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.

;     (NET.TUXEE.AA-MISC::BLEND-VALUE
;      (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y NET.TUXEE.AA-MISC::X
;            NET.TUXEE.AA-MISC::RGB)
;      (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
;      (FLOOR
;       (* NET.TUXEE.AA-MISC::OPACITY
;          (FUNCALL NET.TUXEE.AA-MISC::ALPHA-FUNCTION NET.TUXEE.AA-MISC::ALPHA))))
; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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.

;     (<= 0 NET.TUXEE.AA-MISC::Y (1- NET.TUXEE.AA-MISC::HEIGHT))
; --> 
; --> (LAMBDA (#:G13 #:G12 #:G11) (DECLARE (TYPE REAL #:G13 #:G12 #:G11)) (IF (<= #:G13 #:G12) (IF (<= #:G12 #:G11) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 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.

; --> 
; --> (LAMBDA (#:G13 #:G12 #:G11) (DECLARE (TYPE REAL #:G13 #:G12 #:G11)) (IF (<= #:G13 #:G12) (IF (<= #:G12 #:G11) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 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.

;     (<= 0 NET.TUXEE.AA-MISC::X (1- NET.TUXEE.AA-MISC::WIDTH))
; --> 
; --> (LAMBDA (#:G26 #:G25 #:G24) (DECLARE (TYPE REAL #:G26 #:G25 #:G24)) (IF (<= #:G26 #:G25) (IF (<= #:G25 #:G24) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF <= >= 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.

; --> 
; --> (LAMBDA (#:G26 #:G25 #:G24) (DECLARE (TYPE REAL #:G26 #:G25 #:G24)) (IF (<= #:G26 #:G25) (IF (<= #:G25 #:G24) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF <= >= 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.

; --> 
; --> (LAMBDA (#:G26 #:G25 #:G24) (DECLARE (TYPE REAL #:G26 #:G25 #:G24)) (IF (<= #:G26 #:G25) (IF (<= #:G25 #:G24) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 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.

; --> 
; --> (LAMBDA (#:G26 #:G25 #:G24) (DECLARE (TYPE REAL #:G26 #:G25 #:G24)) (IF (<= #:G26 #:G25) (IF (<= #:G25 #:G24) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 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.

;     (<= 0 NET.TUXEE.AA-MISC::Y (1- NET.TUXEE.AA-MISC::HEIGHT))
; --> 
; --> (LAMBDA (#:G29 #:G28 #:G27) (DECLARE (TYPE REAL #:G29 #:G28 #:G27)) (IF (<= #:G29 #:G28) (IF (<= #:G28 #:G27) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF <= >= 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.

; --> 
; --> (LAMBDA (#:G29 #:G28 #:G27) (DECLARE (TYPE REAL #:G29 #:G28 #:G27)) (IF (<= #:G29 #:G28) (IF (<= #:G28 #:G27) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF <= >= 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.

; --> 
; --> (LAMBDA (#:G29 #:G28 #:G27) (DECLARE (TYPE REAL #:G29 #:G28 #:G27)) (IF (<= #:G29 #:G28) (IF (<= #:G28 #:G27) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 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.

; --> 
; --> (LAMBDA (#:G29 #:G28 #:G27) (DECLARE (TYPE REAL #:G29 #:G28 #:G27)) (IF (<= #:G29 #:G28) (IF (<= #:G28 #:G27) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 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.

;     (<= 0 NET.TUXEE.AA-MISC::X (1- NET.TUXEE.AA-MISC::WIDTH))
; --> 
; --> (LAMBDA (#:G10 #:G9 #:G8) (DECLARE (TYPE REAL #:G10 #:G9 #:G8)) (IF (<= #:G10 #:G9) (IF (<= #:G9 #:G8) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF <= >= IF >= OR LET > 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 REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; --> 
; --> (LAMBDA (#:G10 #:G9 #:G8) (DECLARE (TYPE REAL #:G10 #:G9 #:G8)) (IF (<= #:G10 #:G9) (IF (<= #:G9 #:G8) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 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.

;     (<= 0 NET.TUXEE.AA-MISC::Y (1- NET.TUXEE.AA-MISC::HEIGHT))
; --> 
; --> (LAMBDA (#:G13 #:G12 #:G11) (DECLARE (TYPE REAL #:G13 #:G12 #:G11)) (IF (<= #:G13 #:G12) (IF (<= #:G12 #:G11) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF <= >= IF >= OR LET > 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 REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; --> 
; --> (LAMBDA (#:G13 #:G12 #:G11) (DECLARE (TYPE REAL #:G13 #:G12 #:G11)) (IF (<= #:G13 #:G12) (IF (<= #:G12 #:G11) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 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.

;     (* NET.TUXEE.AA-MISC::OPACITY
;        (FUNCALL NET.TUXEE.AA-MISC::ALPHA-FUNCTION NET.TUXEE.AA-MISC::ALPHA))
; 
; 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 NUMBER, 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (FLOOR
;      (* NET.TUXEE.AA-MISC::OPACITY
;         (FUNCALL NET.TUXEE.AA-MISC::ALPHA-FUNCTION NET.TUXEE.AA-MISC::ALPHA)))
; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET VALUES 
; ==>
;   (- 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 REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; --> FLOOR 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.

; --> FLOOR 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-MISC::BLEND-VALUE
;      (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y NET.TUXEE.AA-MISC::X
;            NET.TUXEE.AA-MISC::RGB)
;      (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
;      (FLOOR
;       (* NET.TUXEE.AA-MISC::OPACITY
;          (FUNCALL NET.TUXEE.AA-MISC::ALPHA-FUNCTION NET.TUXEE.AA-MISC::ALPHA))))
; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR + * 
; ==>
;   (- 256 NET.TUXEE.AA-MISC::ALPHA)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second 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 second 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.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR + 
; ==>
;   (* (- 256 NET.TUXEE.AA-MISC::ALPHA) NET.TUXEE.AA-MISC::A)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 4) 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-MISC::ALPHA NET.TUXEE.AA-MISC::B)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 4) 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.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 
; ==>
;   (+ (* (- 256 NET.TUXEE.AA-MISC::ALPHA) NET.TUXEE.AA-MISC::A)
;      (* NET.TUXEE.AA-MISC::ALPHA NET.TUXEE.AA-MISC::B))
; 
; 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 REAL &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 REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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.

; --> BLOCK MAX LET LET MAX LET MIN LET LET IF <= >= 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 INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> BLOCK MAX LET LET IF >= <= 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 (INTEGER * 255), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER * 255), not a FIXNUM.
;       etc.

;     (<= 0 NET.TUXEE.AA-MISC::X (1- NET.TUXEE.AA-MISC::WIDTH))
; --> 
; --> (LAMBDA (#:G26 #:G25 #:G24) (DECLARE (TYPE REAL #:G26 #:G25 #:G24)) (IF (<= #:G26 #:G25) (IF (<= #:G25 #:G24) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF <= >= IF >= OR LET > 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 REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; --> 
; --> (LAMBDA (#:G26 #:G25 #:G24) (DECLARE (TYPE REAL #:G26 #:G25 #:G24)) (IF (<= #:G26 #:G25) (IF (<= #:G25 #:G24) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 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.

;     (<= 0 NET.TUXEE.AA-MISC::Y (1- NET.TUXEE.AA-MISC::HEIGHT))
; --> 
; --> (LAMBDA (#:G29 #:G28 #:G27) (DECLARE (TYPE REAL #:G29 #:G28 #:G27)) (IF (<= #:G29 #:G28) (IF (<= #:G28 #:G27) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF <= >= IF >= OR LET > 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 REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; --> 
; --> (LAMBDA (#:G29 #:G28 #:G27) (DECLARE (TYPE REAL #:G29 #:G28 #:G27)) (IF (<= #:G29 #:G28) (IF (<= #:G28 #:G27) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 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.

;     (NET.TUXEE.AA-MISC::BLEND-VALUE
;      (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y NET.TUXEE.AA-MISC::X
;            NET.TUXEE.AA-MISC::RGB)
;      (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
;      (FUNCALL NET.TUXEE.AA-MISC::ALPHA-FUNCTION NET.TUXEE.AA-MISC::ALPHA))
; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR + * 
; ==>
;   (- 256 NET.TUXEE.AA-MISC::ALPHA)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       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 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.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR + 
; ==>
;   (* (- 256 NET.TUXEE.AA-MISC::ALPHA) NET.TUXEE.AA-MISC::A)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, 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 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-MISC::ALPHA NET.TUXEE.AA-MISC::B)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, 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 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.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 
; ==>
;   (+ (* (- 256 NET.TUXEE.AA-MISC::ALPHA) NET.TUXEE.AA-MISC::A)
;      (* NET.TUXEE.AA-MISC::ALPHA NET.TUXEE.AA-MISC::B))
; 
; 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 REAL &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 REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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.

; --> BLOCK MAX LET LET MAX LET MIN LET LET IF <= >= 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 INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> BLOCK MAX LET LET IF >= <= 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 (INTEGER * 255), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER * 255), not a FIXNUM.
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-vectors/55f19b15187b1a1026c7fd139fedf3cb7663847b/cl-vectors-20180125-git/aa-misc.lisp
; in: DEFUN IMAGE-PUT-SPAN
;     (< NET.TUXEE.AA-MISC::X1 NET.TUXEE.AA-MISC::WIDTH)
; 
; 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-MISC::X2 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

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

;     (LOOP NET.TUXEE.AA-MISC::FOR NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::FROM (MAX
;                                                                                0
;                                                                                NET.TUXEE.AA-MISC::X1) NET.TUXEE.AA-MISC::BELOW (MIN
;                                                                                                                                 NET.TUXEE.AA-MISC::X2
;                                                                                                                                 NET.TUXEE.AA-MISC::WIDTH)
;           DO (LOOP NET.TUXEE.AA-MISC::FOR NET.TUXEE.AA-MISC::RGB NET.TUXEE.AA-MISC::BELOW 3
;                    DO (SETF (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y
;                                   NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::RGB)
;                               (NET.TUXEE.AA-MISC::BLEND-VALUE # #
;                                NET.TUXEE.AA-MISC::ALPHA))))
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ NET.TUXEE.AA-MISC::X 1)
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y NET.TUXEE.AA-MISC::X
;           NET.TUXEE.AA-MISC::RGB)
; --> 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.

;     (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
; ==>
;   (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.

;     (NET.TUXEE.AA-MISC::BLEND-VALUE
;      (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y NET.TUXEE.AA-MISC::X
;            NET.TUXEE.AA-MISC::RGB)
;      (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
;      NET.TUXEE.AA-MISC::ALPHA)
; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR + 
; ==>
;   (* (- 256 NET.TUXEE.AA-MISC::ALPHA) NET.TUXEE.AA-MISC::A)
; 
; 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.

; ==>
;   (* NET.TUXEE.AA-MISC::ALPHA NET.TUXEE.AA-MISC::B)
; 
; 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.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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).

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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.

;     (MAX 0 NET.TUXEE.AA-MISC::X1)
; --> LET LET IF >= <= 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.

; --> LET LET IF >= <= 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.

;     (NET.TUXEE.AA-MISC::BLEND-VALUE
;      (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y NET.TUXEE.AA-MISC::X
;            NET.TUXEE.AA-MISC::RGB)
;      (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
;      NET.TUXEE.AA-MISC::ALPHA)
; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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.

;     (SETF (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y
;                 NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::RGB)
;             (NET.TUXEE.AA-MISC::BLEND-VALUE
;              (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y
;                    NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::RGB)
;              (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
;              NET.TUXEE.AA-MISC::ALPHA))
; --> 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.

;     (< NET.TUXEE.AA-MISC::X1 NET.TUXEE.AA-MISC::WIDTH)
; 
; 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-MISC::X2 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

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

;     (LOOP NET.TUXEE.AA-MISC::FOR NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::FROM (MAX
;                                                                                0
;                                                                                NET.TUXEE.AA-MISC::X1) NET.TUXEE.AA-MISC::BELOW (MIN
;                                                                                                                                 NET.TUXEE.AA-MISC::X2
;                                                                                                                                 NET.TUXEE.AA-MISC::WIDTH)
;           DO (LOOP NET.TUXEE.AA-MISC::FOR NET.TUXEE.AA-MISC::RGB NET.TUXEE.AA-MISC::BELOW 3
;                    DO (SETF (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y
;                                   NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::RGB)
;                               (NET.TUXEE.AA-MISC::BLEND-VALUE # # #))))
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ NET.TUXEE.AA-MISC::X 1)
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y NET.TUXEE.AA-MISC::X
;           NET.TUXEE.AA-MISC::RGB)
; --> 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.

;     (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
; ==>
;   (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.

;     (* NET.TUXEE.AA-MISC::OPACITY NET.TUXEE.AA-MISC::ALPHA)
; 
; 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.

;     (FLOOR (* NET.TUXEE.AA-MISC::OPACITY NET.TUXEE.AA-MISC::ALPHA))
; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET 
; ==>
;   (SB-KERNEL:%UNARY-TRUNCATE SB-C::X)
; 
; 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.

;     (SETF (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y
;                 NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::RGB)
;             (NET.TUXEE.AA-MISC::BLEND-VALUE
;              (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y
;                    NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::RGB)
;              (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
;              (FLOOR (* NET.TUXEE.AA-MISC::OPACITY NET.TUXEE.AA-MISC::ALPHA))))
; --> 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.

;     (FLOOR (* NET.TUXEE.AA-MISC::OPACITY NET.TUXEE.AA-MISC::ALPHA))
; --> FLOOR 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 (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (<= 0 NET.TUXEE.AA-MISC::Y (1- NET.TUXEE.AA-MISC::HEIGHT))
; --> 
; --> (LAMBDA (#:G10 #:G9 #:G8) (DECLARE (TYPE REAL #:G10 #:G9 #:G8)) (IF (<= #:G10 #:G9) (IF (<= #:G9 #:G8) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 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.

; --> 
; --> (LAMBDA (#:G10 #:G9 #:G8) (DECLARE (TYPE REAL #:G10 #:G9 #:G8)) (IF (<= #:G10 #:G9) (IF (<= #:G9 #:G8) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 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.

;     (FLOOR (* NET.TUXEE.AA-MISC::OPACITY NET.TUXEE.AA-MISC::ALPHA))
; --> FLOOR 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-MISC::BLEND-VALUE
;      (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y NET.TUXEE.AA-MISC::X
;            NET.TUXEE.AA-MISC::RGB)
;      (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
;      (FLOOR (* NET.TUXEE.AA-MISC::OPACITY NET.TUXEE.AA-MISC::ALPHA)))
; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR + 
; ==>
;   (* (- 256 NET.TUXEE.AA-MISC::ALPHA) NET.TUXEE.AA-MISC::A)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The second argument is a NUMBER, not a INTEGER.

; ==>
;   (* NET.TUXEE.AA-MISC::ALPHA NET.TUXEE.AA-MISC::B)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The second argument is a NUMBER, not a INTEGER.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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).

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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.

;     (<= 0 NET.TUXEE.AA-MISC::Y (1- NET.TUXEE.AA-MISC::HEIGHT))
; --> 
; --> (LAMBDA (#:G10 #:G9 #:G8) (DECLARE (TYPE REAL #:G10 #:G9 #:G8)) (IF (<= #:G10 #:G9) (IF (<= #:G9 #:G8) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF <= >= 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.

; --> 
; --> (LAMBDA (#:G10 #:G9 #:G8) (DECLARE (TYPE REAL #:G10 #:G9 #:G8)) (IF (<= #:G10 #:G9) (IF (<= #:G9 #:G8) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF <= >= 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.

;     (NET.TUXEE.AA-MISC::BLEND-VALUE
;      (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y NET.TUXEE.AA-MISC::X
;            NET.TUXEE.AA-MISC::RGB)
;      (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
;      (FLOOR (* NET.TUXEE.AA-MISC::OPACITY NET.TUXEE.AA-MISC::ALPHA)))
; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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.

;     (MIN NET.TUXEE.AA-MISC::X2 NET.TUXEE.AA-MISC::WIDTH)
; --> 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-MISC::FOR NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::FROM (MAX
;                                                                                0
;                                                                                NET.TUXEE.AA-MISC::X1) NET.TUXEE.AA-MISC::BELOW (MIN
;                                                                                                                                 NET.TUXEE.AA-MISC::X2
;                                                                                                                                 NET.TUXEE.AA-MISC::WIDTH)
;           DO (LOOP NET.TUXEE.AA-MISC::FOR NET.TUXEE.AA-MISC::RGB NET.TUXEE.AA-MISC::BELOW 3
;                    DO (SETF (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y
;                                   NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::RGB)
;                               (NET.TUXEE.AA-MISC::BLEND-VALUE # # #))))
; --> 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.

;     (<= 0 NET.TUXEE.AA-MISC::Y (1- NET.TUXEE.AA-MISC::HEIGHT))
; --> 
; --> (LAMBDA (#:G30 #:G29 #:G28) (DECLARE (TYPE REAL #:G30 #:G29 #:G28)) (IF (<= #:G30 #:G29) (IF (<= #:G29 #:G28) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF <= >= 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.

; --> 
; --> (LAMBDA (#:G30 #:G29 #:G28) (DECLARE (TYPE REAL #:G30 #:G29 #:G28)) (IF (<= #:G30 #:G29) (IF (<= #:G29 #:G28) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF <= >= 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.

; --> 
; --> (LAMBDA (#:G30 #:G29 #:G28) (DECLARE (TYPE REAL #:G30 #:G29 #:G28)) (IF (<= #:G30 #:G29) (IF (<= #:G29 #:G28) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 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.

; --> 
; --> (LAMBDA (#:G30 #:G29 #:G28) (DECLARE (TYPE REAL #:G30 #:G29 #:G28)) (IF (<= #:G30 #:G29) (IF (<= #:G29 #:G28) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 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.

;     (MAX 0 NET.TUXEE.AA-MISC::X1)
; --> LET LET IF >= <= 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 >= <= 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-MISC::X2 NET.TUXEE.AA-MISC::WIDTH)
; --> 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-MISC::FOR NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::FROM (MAX
;                                                                                0
;                                                                                NET.TUXEE.AA-MISC::X1) NET.TUXEE.AA-MISC::BELOW (MIN
;                                                                                                                                 NET.TUXEE.AA-MISC::X2
;                                                                                                                                 NET.TUXEE.AA-MISC::WIDTH)
;           DO (LOOP NET.TUXEE.AA-MISC::FOR NET.TUXEE.AA-MISC::RGB NET.TUXEE.AA-MISC::BELOW 3
;                    DO (SETF (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y
;                                   NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::RGB)
;                               (NET.TUXEE.AA-MISC::BLEND-VALUE # #
;                                NET.TUXEE.AA-MISC::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-MISC::X1 NET.TUXEE.AA-MISC::WIDTH)
; 
; 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.

;     (> NET.TUXEE.AA-MISC::X2 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.

;     (<= 0 NET.TUXEE.AA-MISC::Y (1- NET.TUXEE.AA-MISC::HEIGHT))
; --> 
; --> (LAMBDA (#:G10 #:G9 #:G8) (DECLARE (TYPE REAL #:G10 #:G9 #:G8)) (IF (<= #:G10 #:G9) (IF (<= #:G9 #:G8) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF <= >= IF >= OR LET > 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 REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; --> 
; --> (LAMBDA (#:G10 #:G9 #:G8) (DECLARE (TYPE REAL #:G10 #:G9 #:G8)) (IF (<= #:G10 #:G9) (IF (<= #:G9 #:G8) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 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.

;     (MAX 0 NET.TUXEE.AA-MISC::X1)
; --> LET LET IF >= <= IF <= OR LET < 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 REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

;     (MIN NET.TUXEE.AA-MISC::X2 NET.TUXEE.AA-MISC::WIDTH)
; --> 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.

;     (LOOP NET.TUXEE.AA-MISC::FOR NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::FROM (MAX
;                                                                                0
;                                                                                NET.TUXEE.AA-MISC::X1) NET.TUXEE.AA-MISC::BELOW (MIN
;                                                                                                                                 NET.TUXEE.AA-MISC::X2
;                                                                                                                                 NET.TUXEE.AA-MISC::WIDTH)
;           DO (LOOP NET.TUXEE.AA-MISC::FOR NET.TUXEE.AA-MISC::RGB NET.TUXEE.AA-MISC::BELOW 3
;                    DO (SETF (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y
;                                   NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::RGB)
;                               (NET.TUXEE.AA-MISC::BLEND-VALUE # # #))))
; --> 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.

;     (* NET.TUXEE.AA-MISC::OPACITY NET.TUXEE.AA-MISC::ALPHA)
; 
; 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 NUMBER, 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (FLOOR (* NET.TUXEE.AA-MISC::OPACITY NET.TUXEE.AA-MISC::ALPHA))
; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET VALUES 
; ==>
;   (- 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 REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; --> FLOOR 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.

; --> FLOOR 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-MISC::BLEND-VALUE
;      (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y NET.TUXEE.AA-MISC::X
;            NET.TUXEE.AA-MISC::RGB)
;      (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
;      (FLOOR (* NET.TUXEE.AA-MISC::OPACITY NET.TUXEE.AA-MISC::ALPHA)))
; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR + * 
; ==>
;   (- 256 NET.TUXEE.AA-MISC::ALPHA)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second 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 second 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.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR + 
; ==>
;   (* (- 256 NET.TUXEE.AA-MISC::ALPHA) NET.TUXEE.AA-MISC::A)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 4) 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-MISC::ALPHA NET.TUXEE.AA-MISC::B)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 4) 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.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 
; ==>
;   (+ (* (- 256 NET.TUXEE.AA-MISC::ALPHA) NET.TUXEE.AA-MISC::A)
;      (* NET.TUXEE.AA-MISC::ALPHA NET.TUXEE.AA-MISC::B))
; 
; 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 REAL &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 REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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.

; --> BLOCK MAX LET LET MAX LET MIN LET LET IF <= >= 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 INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> BLOCK MAX LET LET IF >= <= 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 (INTEGER * 255), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER * 255), not a FIXNUM.
;       etc.

;     (LOOP NET.TUXEE.AA-MISC::FOR NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::FROM (MAX
;                                                                                0
;                                                                                NET.TUXEE.AA-MISC::X1) NET.TUXEE.AA-MISC::BELOW (MIN
;                                                                                                                                 NET.TUXEE.AA-MISC::X2
;                                                                                                                                 NET.TUXEE.AA-MISC::WIDTH)
;           DO (LOOP NET.TUXEE.AA-MISC::FOR NET.TUXEE.AA-MISC::RGB NET.TUXEE.AA-MISC::BELOW 3
;                    DO (SETF (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y
;                                   NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::RGB)
;                               (NET.TUXEE.AA-MISC::BLEND-VALUE # # #))))
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ NET.TUXEE.AA-MISC::X 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-MISC::X1 NET.TUXEE.AA-MISC::WIDTH)
; 
; 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.

;     (> NET.TUXEE.AA-MISC::X2 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.

;     (<= 0 NET.TUXEE.AA-MISC::Y (1- NET.TUXEE.AA-MISC::HEIGHT))
; --> 
; --> (LAMBDA (#:G30 #:G29 #:G28) (DECLARE (TYPE REAL #:G30 #:G29 #:G28)) (IF (<= #:G30 #:G29) (IF (<= #:G29 #:G28) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF <= >= IF >= OR LET > 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 REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; --> 
; --> (LAMBDA (#:G30 #:G29 #:G28) (DECLARE (TYPE REAL #:G30 #:G29 #:G28)) (IF (<= #:G30 #:G29) (IF (<= #:G29 #:G28) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 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.

;     (MAX 0 NET.TUXEE.AA-MISC::X1)
; --> LET LET IF >= <= IF <= OR LET < 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 REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

;     (MIN NET.TUXEE.AA-MISC::X2 NET.TUXEE.AA-MISC::WIDTH)
; --> 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.

;     (LOOP NET.TUXEE.AA-MISC::FOR NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::FROM (MAX
;                                                                                0
;                                                                                NET.TUXEE.AA-MISC::X1) NET.TUXEE.AA-MISC::BELOW (MIN
;                                                                                                                                 NET.TUXEE.AA-MISC::X2
;                                                                                                                                 NET.TUXEE.AA-MISC::WIDTH)
;           DO (LOOP NET.TUXEE.AA-MISC::FOR NET.TUXEE.AA-MISC::RGB NET.TUXEE.AA-MISC::BELOW 3
;                    DO (SETF (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y
;                                   NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::RGB)
;                               (NET.TUXEE.AA-MISC::BLEND-VALUE # #
;                                NET.TUXEE.AA-MISC::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.

;     (NET.TUXEE.AA-MISC::BLEND-VALUE
;      (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y NET.TUXEE.AA-MISC::X
;            NET.TUXEE.AA-MISC::RGB)
;      (AREF NET.TUXEE.AA-MISC::COLOR NET.TUXEE.AA-MISC::RGB)
;      NET.TUXEE.AA-MISC::ALPHA)
; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR + * 
; ==>
;   (- 256 NET.TUXEE.AA-MISC::ALPHA)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       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 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.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR + 
; ==>
;   (* (- 256 NET.TUXEE.AA-MISC::ALPHA) NET.TUXEE.AA-MISC::A)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, 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 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-MISC::ALPHA NET.TUXEE.AA-MISC::B)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, 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 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.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 
; ==>
;   (+ (* (- 256 NET.TUXEE.AA-MISC::ALPHA) NET.TUXEE.AA-MISC::A)
;      (* NET.TUXEE.AA-MISC::ALPHA NET.TUXEE.AA-MISC::B))
; 
; 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 REAL &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 REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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.

; --> BLOCK MAX LET LET MAX LET MIN LET LET MIN LET FLOOR 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.

; --> BLOCK MAX LET LET MAX LET MIN LET LET IF <= >= 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 INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> BLOCK MAX LET LET IF >= <= 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 (INTEGER * 255), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER * 255), not a FIXNUM.
;       etc.

;     (LOOP NET.TUXEE.AA-MISC::FOR NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::FROM (MAX
;                                                                                0
;                                                                                NET.TUXEE.AA-MISC::X1) NET.TUXEE.AA-MISC::BELOW (MIN
;                                                                                                                                 NET.TUXEE.AA-MISC::X2
;                                                                                                                                 NET.TUXEE.AA-MISC::WIDTH)
;           DO (LOOP NET.TUXEE.AA-MISC::FOR NET.TUXEE.AA-MISC::RGB NET.TUXEE.AA-MISC::BELOW 3
;                    DO (SETF (AREF NET.TUXEE.AA-MISC::IMAGE NET.TUXEE.AA-MISC::Y
;                                   NET.TUXEE.AA-MISC::X NET.TUXEE.AA-MISC::RGB)
;                               (NET.TUXEE.AA-MISC::BLEND-VALUE # #
;                                NET.TUXEE.AA-MISC::ALPHA))))
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ NET.TUXEE.AA-MISC::X 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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/utils/general.lisp
; in: DEFUN DIRECTORY-P
;     (DEFUN GARNET-UTILS:DIRECTORY-P (PATHNAME)
;       (CL-FAD:DIRECTORY-EXISTS-P GARNET-UTILS::FILENAME))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA GARNET-UTILS:DIRECTORY-P
;         (PATHNAME)
;       (BLOCK GARNET-UTILS:DIRECTORY-P
;         (CL-FAD:DIRECTORY-EXISTS-P GARNET-UTILS::FILENAME)))
; 
; caught STYLE-WARNING:
;   The variable PATHNAME is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "org.xoanonos.gui.garnet" "utils" "src/utils/general">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/kr.lisp
; in: DEFUN G-VALUE-INHERIT-VALUES
;     (KR::SET-SLOT-ACCESSOR KR::PARENT KR::SLOT KR::VALUE
;                            (LOGIOR KR::BITS KR::*IS-PARENT-MASK*) NIL)
; --> LET* IF PROGN WHEN IF PROGN SETF LET* 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; --> LET* IF PROGN WHEN IF PROGN SETF SB-KERNEL:%INSTANCE-SET 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/kr.lisp
; in: DEFUN LINK-IN-RELATION
;     (KR::SET-SLOT-ACCESSOR KR::VALUE KR::INVERSE (LIST KR:SCHEMA)
;                            KR::*LOCAL-MASK* NIL)
; --> LET* IF PROGN WHEN IF PROGN SETF LET* 
; ==>
;   KR::INVERSE
; 
; note: deleting unreachable code

; --> LET* IF PROGN WHEN IF PROGN SETF SB-KERNEL:%INSTANCE-SET 
; ==>
;   KR::INVERSE
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/kr.lisp
; in: DEFUN UPDATE-INHERITED-VALUES
;     (KR::RUN-INVALIDATE-DEMONS KR:SCHEMA KR::A-SLOT NIL)
; --> BLOCK UNLESS IF WHEN IF LET KR:GET-VALUE KR::G-VALUE-BODY LOCALLY LET* IF 
; --> ERROR 
; ==>
;   KR:SCHEMA
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/kr.lisp
; in: DEFUN MARK-AS-CHANGED
;     (KR::RUN-INVALIDATE-DEMONS KR:SCHEMA KR::SLOT KR::ENTRY)
; --> BLOCK UNLESS IF WHEN IF LET KR:GET-VALUE KR::G-VALUE-BODY LOCALLY LET* IF 
; --> ERROR 
; ==>
;   KR:SCHEMA
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/kr.lisp
; in: DEFUN RECOMPUTE-FORMULA
;     (KR::RUN-INVALIDATE-DEMONS KR:SCHEMA KR::SLOT KR::ENTRY)
; --> BLOCK UNLESS IF WHEN IF KR::SLOT-REQUIRES-DEMON BLOCK LET OR LET IF 
; --> KR::SLOT-ACCESSOR BLOCK VALUES PROG1 LET GETHASH SB-IMPL::GETHASH3 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; --> BLOCK UNLESS IF WHEN IF LET KR:GET-VALUE KR::G-VALUE-BODY LOCALLY LET* IF 
; --> ERROR 
; ==>
;   KR:SCHEMA
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/kr.lisp
; in: DEFUN RUN-DEMONS-AND-SET-VALUE
;     (KR::SET-SLOT-ACCESSOR KR:SCHEMA KR::SLOT KR::NEW-VALUE KR::NEW-BITS NIL)
; --> LET* IF PROGN WHEN IF PROGN SETF LET* 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; --> LET* IF PROGN WHEN IF PROGN SETF SB-KERNEL:%INSTANCE-SET 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/kr.lisp
; in: DEFUN S-VALUE-FN
;     (VALUES KR::VALUE T)
; ==>
;   KR::VALUE
; 
; note: deleting unreachable code

;     (KR::SET-SLOT-ACCESSOR KR:SCHEMA KR::SLOT KR::VALUE KR::NEW-BITS NIL)
; --> LET* IF PROGN WHEN IF PROGN SETF LET* 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; --> LET* IF PROGN WHEN IF PROGN SETF SB-KERNEL:%INSTANCE-SET 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

;     (KR::RUN-INVALIDATE-DEMONS KR:SCHEMA KR::SLOT KR::ENTRY)
; --> BLOCK UNLESS IF WHEN IF LET KR:GET-VALUE KR::G-VALUE-BODY LOCALLY LET* IF 
; --> ERROR 
; ==>
;   KR:SCHEMA
; 
; note: deleting unreachable code

; --> BLOCK UNLESS IF WHEN IF LET WHEN IF UNLESS IF FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN KR::DEMON)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: DEMON is not known to be a function

;     (KR::RUN-PRE-SET-DEMONS KR:SCHEMA KR::SLOT KR::VALUE NIL :S-VALUE)
; --> UNLESS IF PROGN IF FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN KR::*SLOT-SETTER-DEBUG*)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; --> UNLESS IF PROGN IF IF IF IF FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN KR::*PRE-SET-DEMON*)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

;     (LOGAND KR::THE-BITS KR::*NOT-INHERITED-MASK*)
; 
; note: forced to do full call
;       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 3) 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/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/kr.lisp
; in: DEFUN INTERNAL-S-VALUE
;     (KR::SET-SLOT-ACCESSOR KR:SCHEMA KR::SLOT KR::VALUE KR::*LOCAL-MASK* NIL)
; --> LET* IF PROGN WHEN IF PROGN SETF LET* 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; --> LET* IF PROGN WHEN IF PROGN SETF SB-KERNEL:%INSTANCE-SET 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/kr.lisp
; in: DEFUN DESTROY-SLOT
;     (KR::RUN-INVALIDATE-DEMONS KR:SCHEMA KR::SLOT KR::ENTRY)
; --> BLOCK UNLESS IF WHEN IF KR::SLOT-REQUIRES-DEMON BLOCK LET OR LET IF 
; --> KR::SLOT-ACCESSOR BLOCK VALUES PROG1 LET GETHASH SB-IMPL::GETHASH3 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; --> BLOCK UNLESS IF WHEN IF LET KR:GET-VALUE KR::G-VALUE-BODY LOCALLY LET* IF 
; --> ERROR 
; ==>
;   KR:SCHEMA
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/kr.lisp
; in: DEFUN FORCE-DOWN-HELPER
;     (PUSHNEW KR::SLOT KR::SLOTS)
; --> LET* SETQ THE ADJOIN 
; ==>
;   (SB-KERNEL:%ADJOIN SB-C::ITEM LIST)
; 
; note: unable to optimize due to type uncertainty: can't tell whether the first argument is a (OR FIXNUM SINGLE-FLOAT (NOT NUMBER))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/kr.lisp
; in: DEFUN FORCE-DOWN-ALL-INHERITANCE
;     (KR:GET-VALUE KR:SCHEMA KR::SLOT)
; --> KR::G-VALUE-BODY LOCALLY LET* IF ERROR 
; ==>
;   KR:SCHEMA
; 
; note: deleting unreachable code

; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/kr.lisp
; in: DEFUN MAKE-A-NEW-SCHEMA
;     (FORMAT T "Error in CREATE-SCHEMA - ~S is not a valid schema name.~%"
;             KR::NAME)
; ==>
;   KR::NAME
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/kr.lisp
; in: DEFUN PROCESS-ONE-CONSTANT
;     (KR::SET-SLOT-ACCESSOR KR:SCHEMA KR::SLOT KR::*NO-VALUE* KR::*CONSTANT-MASK*
;                            NIL)
; --> LET* IF PROGN WHEN IF PROGN SETF LET* 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; --> LET* IF PROGN WHEN IF PROGN SETF SB-KERNEL:%INSTANCE-SET 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/kr.lisp
; in: DEFUN PROCESS-CONSTANT-SLOTS
;     (KR::SET-SLOT-ACCESSOR KR::THE-SCHEMA KR::SLOT KR::*NO-VALUE*
;                            (KR::SET-IS-UPDATE-SLOT KR::*LOCAL-MASK*) NIL)
; --> LET* IF PROGN WHEN IF PROGN SETF LET* 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; --> LET* IF PROGN WHEN IF PROGN SETF SB-KERNEL:%INSTANCE-SET 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

;     (KR::SET-SLOT-ACCESSOR KR::THE-SCHEMA KR::SLOT KR::*NO-VALUE* KR::BITS NIL)
; --> LET* IF PROGN WHEN IF PROGN SETF LET* 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; --> LET* IF PROGN WHEN IF PROGN SETF SB-KERNEL:%INSTANCE-SET 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/kr.lisp
; in: DEFUN ADD-UPDATE-SLOT
;     (KR::SET-SLOT-ACCESSOR KR:SCHEMA KR::SLOT KR::*NO-VALUE*
;                            (KR::SET-IS-UPDATE-SLOT KR::*LOCAL-MASK*) NIL)
; --> LET* IF PROGN WHEN IF PROGN SETF LET* 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; --> LET* IF PROGN WHEN IF PROGN SETF SB-KERNEL:%INSTANCE-SET 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/kr.lisp
; in: DEFUN SET-SLOT-TYPE
;     (KR::SET-SLOT-ACCESSOR KR::OBJECT KR::SLOT KR::*NO-VALUE* TYPE NIL)
; --> LET* IF PROGN WHEN IF PROGN SETF LET* 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; --> LET* IF PROGN WHEN IF PROGN SETF SB-KERNEL:%INSTANCE-SET 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/constraints.lisp
; in: DEFUN CHANGE-FORMULA
;     (KR:MARK-AS-CHANGED KR:SCHEMA KR::SLOT)
; --> BLOCK LET KR::RUN-INVALIDATE-DEMONS BLOCK UNLESS IF WHEN IF LET 
; --> KR:GET-VALUE KR::G-VALUE-BODY LOCALLY LET* IF ERROR 
; ==>
;   KR:SCHEMA
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/constraints.lisp
; in: DEFUN MOVE-FORMULA
;     (KR::SET-SLOT-ACCESSOR KR::FROM-SCHEMA KR::FROM-SLOT KR::VALUE
;                            KR::*LOCAL-MASK* NIL)
; --> LET* IF PROGN WHEN IF PROGN SETF LET* 
; ==>
;   KR::FROM-SLOT
; 
; note: deleting unreachable code

; --> LET* IF PROGN WHEN IF PROGN SETF SB-KERNEL:%INSTANCE-SET 
; ==>
;   KR::FROM-SLOT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/constraints.lisp
; in: DEFUN GV-VALUE-FN
;     (KR::SET-SLOT-ACCESSOR KR:SCHEMA KR::SLOT KR::*NO-VALUE* 0 NIL)
; --> LET* IF PROGN WHEN IF PROGN SETF LET* 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; --> LET* IF PROGN WHEN IF PROGN SETF SB-KERNEL:%INSTANCE-SET 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/constraints.lisp
; in: DEFUN DESTROY-CONSTRAINT
;     (KR::SET-SLOT-ACCESSOR KR:SCHEMA KR::SLOT KR::VALUE
;                            (LOGIOR KR::*LOCAL-MASK*
;                                    (LOGAND (KR::SL-BITS KR::ENTRY)
;                                            KR::*IS-UPDATE-SLOT-MASK*))
;                            NIL)
; --> LET* IF PROGN WHEN IF PROGN SETF LET* 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; --> LET* IF PROGN WHEN IF PROGN SETF SB-KERNEL:%INSTANCE-SET 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

;     (KR:MARK-AS-CHANGED KR:SCHEMA KR::SLOT)
; --> BLOCK LET KR::RUN-INVALIDATE-DEMONS BLOCK UNLESS IF WHEN IF LET 
; --> KR:GET-VALUE KR::G-VALUE-BODY LOCALLY LET* IF ERROR 
; ==>
;   KR:SCHEMA
; 
; note: deleting unreachable code

;     (KR:G-CACHED-VALUE KR:SCHEMA KR::SLOT)
; --> BLOCK LET KR:GET-VALUE KR::G-VALUE-BODY LOCALLY LET* IF ERROR 
; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; ==>
;   KR:SCHEMA
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/kr/constraints.lisp
; in: DEFUN I-DEPEND-ON
;     (KR:GET-VALUE KR::OBJECT KR::SLOT)
; --> KR::G-VALUE-BODY LOCALLY LET* IF ERROR 
; ==>
;   KR::OBJECT
; 
; note: deleting unreachable code

; ==>
;   KR::SLOT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/types.lisp
; in: DEF-KR-TYPE (QUOTE (OR NULL (INTEGER 0)))
;     (KR:DEF-KR-TYPE '(OR NULL (INTEGER 0)))
; --> KR::ADD-NEW-TYPE KR::ADD-NEW-TYPE FUNCTION OR LET IF AND IF <= IF <= >= 
; --> 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 INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/types.lisp
; in: DEF-KR-TYPE (QUOTE (REAL 0 1))
;     (KR:DEF-KR-TYPE '(REAL 0 1))
; --> KR::ADD-NEW-TYPE KR::ADD-NEW-TYPE FUNCTION AND IF IF <= >= 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.

; --> KR::ADD-NEW-TYPE KR::ADD-NEW-TYPE FUNCTION AND IF IF <= >= 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.

; --> KR::ADD-NEW-TYPE KR::ADD-NEW-TYPE FUNCTION AND IF >= IF >= <= 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.

; --> KR::ADD-NEW-TYPE KR::ADD-NEW-TYPE FUNCTION AND IF >= IF >= <= 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.

; --> KR::ADD-NEW-TYPE KR::ADD-NEW-TYPE FUNCTION AND IF IF <= >= IF >= OR LET > 
; --> 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 REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; --> KR::ADD-NEW-TYPE KR::ADD-NEW-TYPE FUNCTION AND IF >= IF >= <= IF <= OR 
; --> LET < 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 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/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/types.lisp
; in: DEF-KR-TYPE (QUOTE (INTEGER 0 1))
;     (KR:DEF-KR-TYPE '(INTEGER 0 1))
; --> KR::ADD-NEW-TYPE KR::ADD-NEW-TYPE FUNCTION AND IF IF <= >= 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 INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> KR::ADD-NEW-TYPE KR::ADD-NEW-TYPE FUNCTION AND IF >= IF >= <= 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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/types.lisp
; in: DEF-KR-TYPE (QUOTE (INTEGER 0))
;     (KR:DEF-KR-TYPE '(INTEGER 0))
; --> KR::ADD-NEW-TYPE KR::ADD-NEW-TYPE FUNCTION AND IF <= IF <= >= 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 INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/types.lisp
; in: DEF-KR-TYPE (QUOTE (INTEGER 1))
;     (KR:DEF-KR-TYPE '(INTEGER 1))
; --> KR::ADD-NEW-TYPE KR::ADD-NEW-TYPE FUNCTION AND IF <= IF <= >= 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 INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/types.lisp
; in: DEF-KR-TYPE (QUOTE (INTEGER 2))
;     (KR:DEF-KR-TYPE '(INTEGER 2))
; --> KR::ADD-NEW-TYPE KR::ADD-NEW-TYPE FUNCTION AND IF <= IF <= >= 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 INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/types.lisp
; in: DEF-KR-TYPE (QUOTE (OR KEYWORD (INTEGER 0)))
;     (KR:DEF-KR-TYPE '(OR KEYWORD (INTEGER 0)))
; --> KR::ADD-NEW-TYPE KR::ADD-NEW-TYPE FUNCTION OR LET IF AND IF <= IF <= >= 
; --> 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 INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/create-instances.lisp
; in: CREATE-INSTANCE (QUOTE FONT-FROM-FILE)
;     (KR:O-FORMULA
;      (+ (KR:GVL-FIXNUM :MAX-CHAR-ASCENT) (KR:GVL-FIXNUM :MAX-CHAR-DESCENT)))
; --> KR::O-FORMULA-FN 
; ==>
;   #'(LAMBDA ()
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0) (SPACE 0) (DEBUG 0)))
;       (+ (KR:GVL-FIXNUM :MAX-CHAR-ASCENT) (KR:GVL-FIXNUM :MAX-CHAR-DESCENT)))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/create-instances.lisp
; in: CREATE-INSTANCE (QUOTE FONT)
;     (KR:O-FORMULA
;      (+ (KR:GVL-FIXNUM :MAX-CHAR-ASCENT) (KR:GVL-FIXNUM :MAX-CHAR-DESCENT)))
; --> KR::O-FORMULA-FN 
; ==>
;   #'(LAMBDA ()
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0) (SPACE 0) (DEBUG 0)))
;       (+ (KR:GVL-FIXNUM :MAX-CHAR-ASCENT) (KR:GVL-FIXNUM :MAX-CHAR-DESCENT)))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/create-instances.lisp
; in: CREATE-INSTANCE (QUOTE AGGREGATE)
;     (OPAL:Q-MAX 0 (- OPAL::MAX-Y OPAL::MIN-Y))
; --> BLOCK IF < > IF 
; ==>
;   (> SB-C::Y SB-C::X)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (OPAL:Q-MAX OPAL::MAX-Y
;      (+ (OR (KR:GV OPAL::CHILD :TOP) 0) (OR (KR:GV OPAL::CHILD :HEIGHT) 0)))
; --> BLOCK IF 
; ==>
;   (< OPAL::X OPAL::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.

;     (+ (OR (KR:GV OPAL::CHILD :TOP) 0) (OR (KR:GV OPAL::CHILD :HEIGHT) 0))
; 
; 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.

;     (OPAL:Q-MAX OPAL::MAX-Y
;      (+ (OR (KR:GV OPAL::CHILD :TOP) 0) (OR (KR:GV OPAL::CHILD :HEIGHT) 0)))
; --> BLOCK IF 
; ==>
;   (< OPAL::X OPAL::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.

;     (- OPAL::MAX-Y OPAL::MIN-Y)
; 
; 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 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 REAL, 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.

;     (OPAL:Q-MAX 0 (- OPAL::MAX-Y OPAL::MIN-Y))
; --> BLOCK IF < > IF 
; ==>
;   (> SB-C::Y SB-C::X)
; 
; 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.

;     (KR:O-FORMULA
;      (LET ((OPAL::MAX-X -32767) (OPAL::MIN-X (KR:GVL :LEFT)))
;        (DECLARE (FIXNUM OPAL::MAX-X OPAL::MIN-X))
;        (DOLIST (OPAL::CHILD (KR:GV-LOCAL # :COMPONENTS))
;          (WHEN (KR:GV OPAL::CHILD :VISIBLE) (SETF #)))
;        (OPAL:Q-MAX 0 (- OPAL::MAX-X OPAL::MIN-X))))
; --> KR::O-FORMULA-FN 
; ==>
;   #'(LAMBDA ()
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0) (SPACE 0) (DEBUG 0)))
;       (LET ((OPAL::MAX-X -32767) (OPAL::MIN-X (KR:GVL :LEFT)))
;         (DECLARE (FIXNUM OPAL::MAX-X OPAL::MIN-X))
;         (DOLIST (OPAL::CHILD (KR:GV-LOCAL # :COMPONENTS))
;           (WHEN (KR:GV OPAL::CHILD :VISIBLE) (SETF #)))
;         (OPAL:Q-MAX 0 (- OPAL::MAX-X OPAL::MIN-X))))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/create-instances.lisp
; in: CREATE-INSTANCE (QUOTE LINE)
;     (KR:O-FORMULA
;      (+ (OPAL:Q-ABS (- (OR # 0) (OR # 0)))
;         (*
;          (IF (EQ # :PROJECTING)
;              2
;              1)
;          (OPAL:Q-MAX 1 (THE FIXNUM #)))))
; --> KR::O-FORMULA-FN 
; ==>
;   #'(LAMBDA ()
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0) (SPACE 0) (DEBUG 0)))
;       (+ (OPAL:Q-ABS (- (OR # 0) (OR # 0)))
;          (*
;           (IF (EQ # :PROJECTING)
;               2
;               1)
;           (OPAL:Q-MAX 1 (THE FIXNUM #)))))
; 
; note: doing unsigned word to integer coercion (cost 20) to "<return value>"
; 
; note: doing unsigned word to integer coercion (cost 20) to "<return value>"

;     (FLOOR (OR (KR:GVL :LINE-STYLE :LINE-THICKNESS) 0) 2)
; --> 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 (-2) (2)) 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.
; 
; 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.

;     (KR:O-FORMULA
;      (- (OPAL:Q-MIN (KR:GVL-FIXNUM :Y1) (KR:GVL-FIXNUM :Y2))
;         (IF (EQ (KR:GVL :LINE-STYLE :CAP-STYLE) :PROJECTING)
;             (OPAL:Q-MAX 1 (KR:GVL-FIXNUM :LINE-STYLE :LINE-THICKNESS))
;             (THE FIXNUM (FLOOR # 2))))
;      0)
; --> KR::O-FORMULA-FN 
; ==>
;   #'(LAMBDA ()
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0) (SPACE 0) (DEBUG 0)))
;       (- (OPAL:Q-MIN (KR:GVL-FIXNUM :Y1) (KR:GVL-FIXNUM :Y2))
;          (IF (EQ (KR:GVL :LINE-STYLE :CAP-STYLE) :PROJECTING)
;              (OPAL:Q-MAX 1 (KR:GVL-FIXNUM :LINE-STYLE :LINE-THICKNESS))
;              (THE FIXNUM (FLOOR # 2)))))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

;     (FLOOR (OR (KR:GVL :LINE-STYLE :LINE-THICKNESS) 0) 2)
; --> 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 (-2) (2)) 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.
; 
; 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.

;     (KR:O-FORMULA
;      (- (OPAL:Q-MIN (KR:GVL-FIXNUM :X1) (KR:GVL-FIXNUM :X2))
;         (IF (EQ (KR:GVL :LINE-STYLE :CAP-STYLE) :PROJECTING)
;             (OPAL:Q-MAX 1 (THE FIXNUM #))
;             (THE FIXNUM (FLOOR # 2))))
;      0)
; --> KR::O-FORMULA-FN 
; ==>
;   #'(LAMBDA ()
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0) (SPACE 0) (DEBUG 0)))
;       (- (OPAL:Q-MIN (KR:GVL-FIXNUM :X1) (KR:GVL-FIXNUM :X2))
;          (IF (EQ (KR:GVL :LINE-STYLE :CAP-STYLE) :PROJECTING)
;              (OPAL:Q-MAX 1 (THE FIXNUM #))
;              (THE FIXNUM (FLOOR # 2)))))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/create-instances.lisp
; in: CREATE-INSTANCE (QUOTE ROUNDTANGLE)
;     (FLOOR OPAL::SMALLER-SIDE 5)
; --> 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 FIXNUM, not a (UNSIGNED-BYTE 64).

;     (FLOOR OPAL::SMALLER-SIDE 3)
; --> 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 FIXNUM, not a (UNSIGNED-BYTE 64).

;     (OPAL:Q-MAX OPAL::R 0)
; --> BLOCK IF 
; ==>
;   (< OPAL::X OPAL::Y)
; 
; 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 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/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/create-instances.lisp
; in: CREATE-INSTANCE (QUOTE MULTIPOINT)
;     (OPAL:Q-MAX 1 (KR:GV OPAL:LINE-STYLE :LINE-THICKNESS))
; --> BLOCK IF < > IF 
; ==>
;   (> SB-C::Y SB-C::X)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (* 4 (OPAL:Q-MAX 1 (KR:GV OPAL:LINE-STYLE :LINE-THICKNESS)))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to associate */(* /) of constants due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (OPAL:Q-MAX OPAL::MAX-Y (CADR OPAL::POINT))
; --> BLOCK IF 
; ==>
;   (< OPAL::X OPAL::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.

;     (OPAL:Q-MAX 1 (KR:GV OPAL:LINE-STYLE :LINE-THICKNESS))
; --> BLOCK IF < > IF 
; ==>
;   (> SB-C::Y SB-C::X)
; 
; 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.

;     (* 4 (OPAL:Q-MAX 1 (KR:GV OPAL:LINE-STYLE :LINE-THICKNESS)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 3) 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 (signed-byte 64) arithmetic (cost 4) because:
;       The first 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.

;     (- OPAL::MAX-Y OPAL::MIN-Y)
; 
; note: forced to do GENERIC-- (cost 10)
;       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).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first 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.

;     (+ (- OPAL::MAX-Y OPAL::MIN-Y) OPAL::LSTHICKNESS)
; 
; 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.

;     (OPAL:Q-MAX OPAL::MAX-Y (CADR OPAL::POINT))
; --> BLOCK IF 
; ==>
;   (< OPAL::X OPAL::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.

;     (OPAL:Q-MAX 1 (KR:GV OPAL:LINE-STYLE :LINE-THICKNESS))
; --> BLOCK IF < > IF 
; ==>
;   (> SB-C::Y SB-C::X)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (* 4 (OPAL:Q-MAX 1 (KR:GV OPAL:LINE-STYLE :LINE-THICKNESS)))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to associate */(* /) of constants due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (OPAL:Q-MAX OPAL::MAX-X (CAR OPAL::POINT))
; --> BLOCK IF 
; ==>
;   (< OPAL::X OPAL::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.

;     (OPAL:Q-MAX 1 (KR:GV OPAL:LINE-STYLE :LINE-THICKNESS))
; --> BLOCK IF < > IF 
; ==>
;   (> SB-C::Y SB-C::X)
; 
; 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.

;     (* 4 (OPAL:Q-MAX 1 (KR:GV OPAL:LINE-STYLE :LINE-THICKNESS)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 3) 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 (signed-byte 64) arithmetic (cost 4) because:
;       The first 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.

;     (- OPAL::MAX-X OPAL::MIN-X)
; 
; note: forced to do GENERIC-- (cost 10)
;       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).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first 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.

;     (+ (- OPAL::MAX-X OPAL::MIN-X) OPAL::LSTHICKNESS)
; 
; 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.

;     (OPAL:Q-MAX OPAL::MAX-X (CAR OPAL::POINT))
; --> BLOCK IF 
; ==>
;   (< OPAL::X OPAL::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.

;     (* 2 (OPAL:Q-MAX 1 (KR:GV OPAL:LINE-STYLE :LINE-THICKNESS)))
; 
; 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 x*2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to associate */(* /) of constants due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (OPAL:Q-MAX 1 (KR:GV OPAL:LINE-STYLE :LINE-THICKNESS))
; --> BLOCK IF < > IF 
; ==>
;   (> SB-C::Y SB-C::X)
; 
; 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 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.

;     (* 2 (OPAL:Q-MAX 1 (KR:GV OPAL:LINE-STYLE :LINE-THICKNESS)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 3) 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 (signed-byte 64) arithmetic (cost 4) because:
;       The first 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.

;     (- OPAL::MIN-Y OPAL::LSTHICKNESS)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       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 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.

;     (* 2 (OPAL:Q-MAX 1 (KR:GV OPAL:LINE-STYLE :LINE-THICKNESS)))
; 
; 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 x*2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to associate */(* /) of constants due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (OPAL:Q-MAX 1 (KR:GV OPAL:LINE-STYLE :LINE-THICKNESS))
; --> BLOCK IF < > IF 
; ==>
;   (> SB-C::Y SB-C::X)
; 
; 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 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.

;     (* 2 (OPAL:Q-MAX 1 (KR:GV OPAL:LINE-STYLE :LINE-THICKNESS)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 3) 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 (signed-byte 64) arithmetic (cost 4) because:
;       The first 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.

;     (- OPAL::MIN-X OPAL::LSTHICKNESS)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       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 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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/create-instances.lisp
; in: CREATE-INSTANCE (QUOTE ARROWHEAD)
;     (* (KR:GVL :RADIUS) (KR:GVL :UX))
; 
; 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.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, 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 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.

;     (- (KR:GVL :CONNECT-Y) (* (KR:GVL :RADIUS) (KR:GVL :UX)))
; 
; 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 REAL &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 REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (ROUND (- (KR:GVL :CONNECT-Y) (* (KR:GVL :RADIUS) (KR:GVL :UX))))
; --> ROUND LET 
; ==>
;   (SB-KERNEL:%UNARY-ROUND SB-C::X)
; 
; note: forced to do full call
;       unable to do inline float truncate (cost 5) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       unable to do inline float truncate (cost 5) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

; --> ROUND LET VALUES 
; ==>
;   (- 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 REAL, not a FIXNUM.
;       The second argument is a INTEGER, 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 REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (* (KR:GVL :RADIUS) (KR:GVL :UY))
; 
; 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.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, 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 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.

;     (+ (KR:GVL :CONNECT-X) (* (KR:GVL :RADIUS) (KR:GVL :UY)))
; 
; 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 REAL &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 REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (ROUND (+ (KR:GVL :CONNECT-X) (* (KR:GVL :RADIUS) (KR:GVL :UY))))
; --> ROUND LET 
; ==>
;   (SB-KERNEL:%UNARY-ROUND SB-C::X)
; 
; note: forced to do full call
;       unable to do inline float truncate (cost 5) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       unable to do inline float truncate (cost 5) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

; --> ROUND LET VALUES 
; ==>
;   (- 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 REAL, not a FIXNUM.
;       The second argument is a INTEGER, 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 REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (* (KR:GVL :RADIUS) (KR:GVL :UX))
; 
; 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.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, 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 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.

;     (+ (KR:GVL :CONNECT-Y) (* (KR:GVL :RADIUS) (KR:GVL :UX)))
; 
; 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 REAL &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 REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (ROUND (+ (KR:GVL :CONNECT-Y) (* (KR:GVL :RADIUS) (KR:GVL :UX))))
; --> ROUND LET 
; ==>
;   (SB-KERNEL:%UNARY-ROUND SB-C::X)
; 
; note: forced to do full call
;       unable to do inline float truncate (cost 5) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       unable to do inline float truncate (cost 5) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

; --> ROUND LET VALUES 
; ==>
;   (- 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 REAL, not a FIXNUM.
;       The second argument is a INTEGER, 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 REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (* (KR:GVL :RADIUS) (KR:GVL :UY))
; 
; 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.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, 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 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.

;     (- (KR:GVL :CONNECT-X) (* (KR:GVL :RADIUS) (KR:GVL :UY)))
; 
; 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 REAL &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 REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (ROUND (- (KR:GVL :CONNECT-X) (* (KR:GVL :RADIUS) (KR:GVL :UY))))
; --> ROUND LET 
; ==>
;   (SB-KERNEL:%UNARY-ROUND SB-C::X)
; 
; note: forced to do full call
;       unable to do inline float truncate (cost 5) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       unable to do inline float truncate (cost 5) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

; --> ROUND LET VALUES 
; ==>
;   (- 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 REAL, not a FIXNUM.
;       The second argument is a INTEGER, 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 REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (* (KR:GVL-FIXNUM :LENGTH) (KR:GVL :UY))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The second argument is a NUMBER, not a INTEGER.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 4) because:
;       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 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.

;     (+ (KR:GVL-FIXNUM :HEAD-Y) (* (KR:GVL-FIXNUM :LENGTH) (KR:GVL :UY)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a NUMBER, 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 second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (ROUND (+ (KR:GVL-FIXNUM :HEAD-Y) (* (KR:GVL-FIXNUM :LENGTH) (KR:GVL :UY))))
; --> ROUND LET 
; ==>
;   (SB-KERNEL:%UNARY-ROUND SB-C::X)
; 
; note: forced to do full call
;       unable to do inline float truncate (cost 5) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       unable to do inline float truncate (cost 5) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

; --> ROUND LET VALUES 
; ==>
;   (- 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 REAL, not a FIXNUM.
;       The second argument is a INTEGER, 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 REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (* (KR:GVL-FIXNUM :LENGTH) (KR:GVL :UX))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The second argument is a NUMBER, not a INTEGER.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 4) because:
;       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 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.

;     (+ (KR:GVL-FIXNUM :HEAD-X) (* (KR:GVL-FIXNUM :LENGTH) (KR:GVL :UX)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a NUMBER, 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 second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (ROUND (+ (KR:GVL-FIXNUM :HEAD-X) (* (KR:GVL-FIXNUM :LENGTH) (KR:GVL :UX))))
; --> ROUND LET 
; ==>
;   (SB-KERNEL:%UNARY-ROUND SB-C::X)
; 
; note: forced to do full call
;       unable to do inline float truncate (cost 5) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       unable to do inline float truncate (cost 5) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

; --> ROUND LET VALUES 
; ==>
;   (- 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 REAL, not a FIXNUM.
;       The second argument is a INTEGER, 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 REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (SQRT
;      (+ (THE FIXNUM (* OPAL::DX OPAL::DX)) (THE FIXNUM (* OPAL::DY OPAL::DY))))
; 
; note: doing signed word to integer coercion (cost 20)

;     (KR:O-FORMULA (- (KR:GVL-FIXNUM :FROM-Y) (KR:GVL-FIXNUM :HEAD-Y)))
; --> KR::O-FORMULA-FN 
; ==>
;   #'(LAMBDA ()
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0) (SPACE 0) (DEBUG 0)))
;       (- (KR:GVL-FIXNUM :FROM-Y) (KR:GVL-FIXNUM :HEAD-Y)))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

;     (KR:O-FORMULA (- (KR:GVL-FIXNUM :FROM-X) (KR:GVL-FIXNUM :HEAD-X)))
; --> KR::O-FORMULA-FN 
; ==>
;   #'(LAMBDA ()
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0) (SPACE 0) (DEBUG 0)))
;       (- (KR:GVL-FIXNUM :FROM-X) (KR:GVL-FIXNUM :HEAD-X)))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/gem/gem.lisp
; in: DEFSTRUCT DISPLAY-INFO
;     (DEFSTRUCT (GEM:DISPLAY-INFO (:PRINT-FUNCTION GEM::DISPLAY-INFO-PRINTER))
;       GEM::DISPLAY
;       GEM::SCREEN
;       GEM::ROOT-WINDOW
;       GEM::LINE-STYLE-GC
;       GEM::FILLING-STYLE-GC)
; --> PROGN EVAL-WHEN 
; ==>
;   (SB-KERNEL::%COMPILER-DEFSTRUCT
;    '#<SB-KERNEL:DEFSTRUCT-DESCRIPTION GEM:DISPLAY-INFO {100A9114C3}>
;    '#(#<SB-KERNEL:LAYOUT for T {20300003}>
;       #<SB-KERNEL:LAYOUT for STRUCTURE-OBJECT {20300103}>))
; 
; caught STYLE-WARNING:
;   Previously compiled call to GEM:DISPLAY-INFO-ROOT-WINDOW could not be inlined because the structure definition for GEM:DISPLAY-INFO was not yet seen. To avoid this warning, DEFSTRUCT should precede references to the affected functions, or they must be declared locally notinline at each call site.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "org.xoanonos.gui.garnet" "gem" "gem">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/gem/x.lisp
; in: DEFUN X-DISCARD-MOUSE-MOVED-EVENTS
;     (INCF GEM::*MOUSE-THROW-AWAYS*)
; --> SETQ THE 
; ==>
;   (+ 1 GEM::*MOUSE-THROW-AWAYS*)
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.
; 
; 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/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/gem/x.lisp
; in: DEFUN X-EVENT-HANDLER
;     (XLIB:EVENT-CASE (GEM::DISPLAY :DISCARD-P T :TIMEOUT
;                       (IF GEM::IGNORE-KEYS
;                           0
;                           NIL))
;       (:CLIENT-MESSAGE (GEM::EVENT-WINDOW TYPE GEM::DATA FORMAT)
;        (GEM::EVENT-HANDLER-DEBUG :CLIENT-MESSAGE GEM::EVENT-WINDOW TYPE GEM::DATA
;                                  FORMAT)
;        (INTERACTORS::DO-CLIENT-MESSAGE GEM::EVENT-WINDOW TYPE GEM::DATA FORMAT
;         GEM::DISPLAY))
;       (:MAP-NOTIFY (GEM::EVENT-WINDOW) (GEM::EVENT-HANDLER-DEBUG :MAP-NOTIFY)
;        (INTERACTORS::DO-MAP-NOTIFY
;         (GEM::X-WINDOW-FROM-DRAWABLE GEM::ROOT-WINDOW GEM::EVENT-WINDOW)))
;       (:UNMAP-NOTIFY (GEM::EVENT-WINDOW) (GEM::EVENT-HANDLER-DEBUG :UNMAP-NOTIFY)
;        (INTERACTORS::DO-UNMAP-NOTIFY
;         (GEM::X-WINDOW-FROM-DRAWABLE GEM::ROOT-WINDOW GEM::EVENT-WINDOW)))
;       (:REPARENT-NOTIFY (GEM::EVENT-WINDOW)
;        (GEM::EVENT-HANDLER-DEBUG :REPARENT-NOTIFY)
;        (IF (GEM::CONNECTED-WINDOW-P GEM::EVENT-WINDOW)
;            (LET (#)
;              (KR:S-VALUE GEM::WINDOW :ALREADY-INITIALIZED-BORDER-WIDTHS NIL)
;              (KR:S-VALUE GEM::WINDOW :LINEAGE #))))
;       (:CIRCULATE-NOTIFY NIL (GEM::EVENT-HANDLER-DEBUG :CIRCULATE-NOTIFY)
;        (INTERACTORS::DO-CIRCULATE-NOTIFY))
;       (:GRAVITY-NOTIFY NIL (GEM::EVENT-HANDLER-DEBUG :GRAVITY-NOTIFY)
;        (INTERACTORS::DO-GRAVITY-NOTIFY))
;       (:DESTROY-NOTIFY (GEM::EVENT-WINDOW)
;        (GEM::EVENT-HANDLER-DEBUG :DESTROY-NOTIFY)
;        (GEM::DESTROY-NOTIFY-WINDOW GEM::EVENT-WINDOW))
;       (:CONFIGURE-NOTIFY
;        (GEM::EVENT-WINDOW GEM::X GEM::Y GEM::WIDTH GEM::HEIGHT
;         GEM::ABOVE-SIBLING)
;        (GEM::EVENT-HANDLER-DEBUG :CONFIGURE-NOTIFY)
;        (IF (GEM::CONNECTED-WINDOW-P GEM::EVENT-WINDOW)
;            (INTERACTORS::DO-CONFIGURE-NOTIFY
;             (GEM::X-WINDOW-FROM-DRAWABLE GEM::ROOT-WINDOW GEM::EVENT-WINDOW)
;             GEM::X GEM::Y GEM::WIDTH GEM::HEIGHT GEM::ABOVE-SIBLING)))
;       (:EXPOSURE (GEM::EVENT-WINDOW GEM::X GEM::Y GEM::WIDTH GEM::HEIGHT COUNT)
;        (GEM::EVENT-HANDLER-DEBUG :EXPOSURE GEM::X GEM::Y GEM::WIDTH GEM::HEIGHT
;                                  COUNT)
;        (WHEN (GEM::CONNECTED-WINDOW-P GEM::EVENT-WINDOW)
;          (INTERACTORS::DO-EXPOSURE
;           (GEM::X-WINDOW-FROM-DRAWABLE GEM::ROOT-WINDOW GEM::EVENT-WINDOW) GEM::X
;           GEM::Y GEM::WIDTH GEM::HEIGHT COUNT GEM::DISPLAY)))
;       (:KEY-PRESS (GEM::EVENT-WINDOW GEM::X GEM::Y GEM::STATE GEM::CODE TIME)
;        (GEM::EVENT-HANDLER-DEBUG :KEY-PRESS GEM::EVENT-WINDOW GEM::X GEM::Y
;                                  GEM::STATE GEM::CODE TIME)
;        (IF GEM::IGNORE-KEYS
;            (LET (#)
;              (WHEN # # #))
;            (INTERACTORS::DO-KEY-PRESS
;             (GEM::X-WINDOW-FROM-DRAWABLE GEM::ROOT-WINDOW GEM::EVENT-WINDOW)
;             GEM::X GEM::Y GEM::STATE GEM::CODE TIME)))
;       ...)
; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF PROGN 
; --> XLIB::BINDING-EVENT-VALUES LET LET LET* 
; ==>
;   (MAKE-ARRAY (CEILING 160 FORMAT) :ELEMENT-TYPE `(UNSIGNED-BYTE ,FORMAT))
; 
; note: unable to optimize because: ELEMENT-TYPE is not constant.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF PROGN 
; --> XLIB::BINDING-EVENT-VALUES LET LET 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:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF PROGN 
; --> XLIB::BINDING-EVENT-VALUES LET LET 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:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF PROGN 
; --> XLIB::BINDING-EVENT-VALUES LET LET 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:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF IF IF IF IF IF IF 
; --> IF PROGN XLIB::BINDING-EVENT-VALUES LET LET LET MACROLET IF ZEROP 
; ==>
;   (= #:G0 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF IF IF IF IF IF IF 
; --> IF IF IF PROGN XLIB::BINDING-EVENT-VALUES LET LET LET MACROLET IF ZEROP 
; ==>
;   (= #:G0 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF IF IF IF IF IF IF 
; --> IF IF IF IF PROGN XLIB::BINDING-EVENT-VALUES LET LET LET MACROLET IF 
; --> ZEROP 
; ==>
;   (= #:G0 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF IF IF IF IF IF IF 
; --> IF IF IF IF IF PROGN XLIB::BINDING-EVENT-VALUES LET LET LET MACROLET IF 
; --> ZEROP 
; ==>
;   (= #:G0 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF IF IF IF IF IF IF 
; --> IF IF IF IF IF IF IF PROGN XLIB::BINDING-EVENT-VALUES LET LET LET 
; --> MACROLET IF ZEROP 
; ==>
;   (= #:G1 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF IF IF IF IF IF IF 
; --> IF IF IF IF IF IF IF IF PROGN XLIB::BINDING-EVENT-VALUES LET LET LET 
; --> MACROLET IF ZEROP 
; ==>
;   (= #:G1 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> PROGN XLIB::BINDING-EVENT-VALUES LET LET LET* 
; ==>
;   (MAKE-ARRAY (CEILING 160 FORMAT) :ELEMENT-TYPE `(UNSIGNED-BYTE ,FORMAT))
; 
; note: unable to optimize because: ELEMENT-TYPE is not constant.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> PROGN XLIB::BINDING-EVENT-VALUES LET LET 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:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> PROGN XLIB::BINDING-EVENT-VALUES LET LET 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:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> PROGN XLIB::BINDING-EVENT-VALUES LET LET 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:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> IF IF IF IF IF IF IF PROGN XLIB::BINDING-EVENT-VALUES LET LET LET 
; --> MACROLET IF ZEROP 
; ==>
;   (= #:G0 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> IF IF IF IF IF IF IF IF IF PROGN XLIB::BINDING-EVENT-VALUES LET LET LET 
; --> MACROLET IF ZEROP 
; ==>
;   (= #:G0 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> IF IF IF IF IF IF IF IF IF IF PROGN XLIB::BINDING-EVENT-VALUES LET LET 
; --> LET MACROLET IF ZEROP 
; ==>
;   (= #:G0 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> IF IF IF IF IF IF IF IF IF IF IF PROGN XLIB::BINDING-EVENT-VALUES LET LET 
; --> LET MACROLET IF ZEROP 
; ==>
;   (= #:G0 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> IF IF IF IF IF IF IF IF IF IF IF IF IF PROGN XLIB::BINDING-EVENT-VALUES 
; --> LET LET LET MACROLET IF ZEROP 
; ==>
;   (= #:G1 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> IF IF IF IF IF IF IF IF IF IF IF IF IF IF PROGN 
; --> XLIB::BINDING-EVENT-VALUES LET LET LET MACROLET IF ZEROP 
; ==>
;   (= #:G1 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/gem/x.lisp
; in: DEFUN FETCH-NEXT-EVENT
;     (XLIB:EVENT-CASE (GEM::DISPLAY :DISCARD-P T :TIMEOUT
;                       (IF GEM::IGNORE-KEYS
;                           0
;                           NIL))
;       (:CLIENT-MESSAGE (GEM::EVENT-WINDOW TYPE GEM::DATA FORMAT)
;        (SETF GEM::NEW-EVENT-TYPE :CLIENT-MESSAGE
;              GEM::NEW-EVENT-WINDOW GEM::EVENT-WINDOW
;              GEM::NEW-TYPE TYPE
;              GEM::NEW-DATA GEM::DATA
;              GEM::NEW-FORMAT FORMAT))
;       (:MAP-NOTIFY (GEM::EVENT-WINDOW)
;        (SETF GEM::NEW-EVENT-TYPE :CLIENT-MESSAGE
;              GEM::NEW-EVENT-WINDOW GEM::EVENT-WINDOW))
;       (:UNMAP-NOTIFY (GEM::EVENT-WINDOW)
;        (SETF GEM::NEW-EVENT-TYPE :UNMAP-NOTIFY
;              GEM::NEW-EVENT-WINDOW GEM::EVENT-WINDOW))
;       (:REPARENT-NOTIFY (GEM::EVENT-WINDOW)
;        (SETF GEM::NEW-EVENT-TYPE :REPARENT-NOTIFY
;              GEM::NEW-EVENT-WINDOW GEM::EVENT-WINDOW))
;       (:CIRCULATE-NOTIFY NIL (SETF GEM::NEW-EVENT-TYPE :CIRCULATE-NOTIFY))
;       (:GRAVITY-NOTIFY NIL (SETF GEM::NEW-EVENT-TYPE :GRAVITY-NOTIFY))
;       (:DESTROY-NOTIFY (GEM::EVENT-WINDOW)
;        (SETF GEM::NEW-EVENT-TYPE :DESTROY-NOTIFY
;              GEM::NEW-EVENT-WINDOW GEM::EVENT-WINDOW))
;       (:CONFIGURE-NOTIFY
;        (GEM::EVENT-WINDOW GEM::X GEM::Y GEM::WIDTH GEM::HEIGHT
;         GEM::ABOVE-SIBLING)
;        (SETF GEM::NEW-EVENT-TYPE :CONFIGURE-NOTIFY
;              GEM::NEW-EVENT-WINDOW GEM::EVENT-WINDOW
;              GEM::NEW-X GEM::X
;              GEM::NEW-Y GEM::Y
;              GEM::NEW-WIDTH GEM::WIDTH
;              GEM::NEW-HEIGHT GEM::HEIGHT
;              ...))
;       (:EXPOSURE (GEM::EVENT-WINDOW GEM::X GEM::Y GEM::WIDTH GEM::HEIGHT COUNT)
;        (SETF GEM::NEW-EVENT-TYPE :EXPOSURE
;              GEM::NEW-EVENT-WINDOW GEM::EVENT-WINDOW
;              GEM::NEW-X GEM::X
;              GEM::NEW-Y GEM::Y
;              GEM::NEW-WIDTH GEM::WIDTH
;              GEM::NEW-HEIGHT GEM::HEIGHT
;              ...))
;       (:KEY-PRESS (GEM::EVENT-WINDOW GEM::X GEM::Y GEM::STATE GEM::CODE TIME)
;        (SETF GEM::NEW-EVENT-TYPE :KEY-PRESS
;              GEM::NEW-EVENT-WINDOW GEM::EVENT-WINDOW
;              GEM::NEW-X GEM::X
;              GEM::NEW-Y GEM::Y
;              GEM::NEW-STATE GEM::STATE
;              GEM::NEW-CODE GEM::CODE
;              ...))
;       ...)
; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF PROGN 
; --> XLIB::BINDING-EVENT-VALUES LET LET LET* 
; ==>
;   (MAKE-ARRAY (CEILING 160 FORMAT) :ELEMENT-TYPE `(UNSIGNED-BYTE ,FORMAT))
; 
; note: unable to optimize because: ELEMENT-TYPE is not constant.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF PROGN 
; --> XLIB::BINDING-EVENT-VALUES LET LET 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:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF PROGN 
; --> XLIB::BINDING-EVENT-VALUES LET LET 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:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF PROGN 
; --> XLIB::BINDING-EVENT-VALUES LET LET 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:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF IF IF IF IF IF IF 
; --> IF PROGN XLIB::BINDING-EVENT-VALUES LET LET LET MACROLET IF ZEROP 
; ==>
;   (= #:G0 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF IF IF IF IF IF IF 
; --> IF IF IF PROGN XLIB::BINDING-EVENT-VALUES LET LET LET MACROLET IF ZEROP 
; ==>
;   (= #:G0 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF IF IF IF IF IF IF 
; --> IF IF IF IF PROGN XLIB::BINDING-EVENT-VALUES LET LET LET MACROLET IF 
; --> ZEROP 
; ==>
;   (= #:G0 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF IF IF IF IF IF IF 
; --> IF IF IF IF IF PROGN XLIB::BINDING-EVENT-VALUES LET LET LET MACROLET IF 
; --> ZEROP 
; ==>
;   (= #:G0 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF IF IF IF IF IF IF 
; --> IF IF IF IF IF IF IF PROGN XLIB::BINDING-EVENT-VALUES LET LET LET 
; --> MACROLET IF ZEROP 
; ==>
;   (= #:G1 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET 
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP 
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT 
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF IF IF IF IF IF IF 
; --> IF IF IF IF IF IF IF IF PROGN XLIB::BINDING-EVENT-VALUES LET LET LET 
; --> MACROLET IF ZEROP 
; ==>
;   (= #:G1 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> PROGN XLIB::BINDING-EVENT-VALUES LET LET LET* 
; ==>
;   (MAKE-ARRAY (CEILING 160 FORMAT) :ELEMENT-TYPE `(UNSIGNED-BYTE ,FORMAT))
; 
; note: unable to optimize because: ELEMENT-TYPE is not constant.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> PROGN XLIB::BINDING-EVENT-VALUES LET LET 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:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> PROGN XLIB::BINDING-EVENT-VALUES LET LET 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:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> PROGN XLIB::BINDING-EVENT-VALUES LET LET 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:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> IF IF IF IF IF IF IF PROGN XLIB::BINDING-EVENT-VALUES LET LET LET 
; --> MACROLET IF ZEROP 
; ==>
;   (= #:G0 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> IF IF IF IF IF IF IF IF IF PROGN XLIB::BINDING-EVENT-VALUES LET LET LET 
; --> MACROLET IF ZEROP 
; ==>
;   (= #:G0 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> IF IF IF IF IF IF IF IF IF IF PROGN XLIB::BINDING-EVENT-VALUES LET LET 
; --> LET MACROLET IF ZEROP 
; ==>
;   (= #:G0 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> IF IF IF IF IF IF IF IF IF IF IF PROGN XLIB::BINDING-EVENT-VALUES LET LET 
; --> LET MACROLET IF ZEROP 
; ==>
;   (= #:G0 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> IF IF IF IF IF IF IF IF IF IF IF IF IF PROGN XLIB::BINDING-EVENT-VALUES 
; --> LET LET LET MACROLET IF ZEROP 
; ==>
;   (= #:G1 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE MACROLET 
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET BLOCK SB-THREAD:WITH-RECURSIVE-LOCK 
; --> SB-INT:DX-FLET FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP 
; --> BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET 
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK 
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH 
; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF 
; --> IF IF IF IF IF IF IF IF IF IF IF IF IF IF PROGN 
; --> XLIB::BINDING-EVENT-VALUES LET LET LET MACROLET IF ZEROP 
; ==>
;   (= #:G1 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; 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)).
; 
; note: unable to open code because: The operands might not be the same type.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/gem/x.lisp
; in: DEFUN FIX-FONT-PATH
;     'STRING
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/text.lisp
; in: CREATE-INSTANCE (QUOTE TEXT)
;     (SUBSEQ STRING 0 OPAL::FIXED-INDEX)
; ==>
;   OPAL::FIXED-INDEX
; 
; note: deleting unreachable code

;     (+
;      (MAX (MIN OPAL::MAX-CURSOR-OFFSET OPAL::BASE-WIDTH)
;           OPAL::*CURSOR-HALF-WIDTH*)
;      (CASE OPAL::JUSTIFICATION
;        (:RIGHT (- OPAL::MAX-LINE-WIDTH (MAX OPAL::LINE-WIDTH 2)))
;        (:CENTER (FLOOR (- OPAL::MAX-LINE-WIDTH OPAL::LINE-WIDTH) 2))
;        (T 0)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (INTEGER -9223372036854775807 4611686018427387903), not a FIXNUM.
;       The result is a (VALUES (INTEGER -13835058055282163711 9223372036854775806) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The result is a (VALUES (INTEGER -13835058055282163711 9223372036854775806) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (MIN OPAL::MAX-CURSOR-OFFSET
;          (+
;           (MAX (MIN OPAL::MAX-CURSOR-OFFSET OPAL::BASE-WIDTH)
;                OPAL::*CURSOR-HALF-WIDTH*)
;           (CASE OPAL::JUSTIFICATION
;             (:RIGHT (- OPAL::MAX-LINE-WIDTH #))
;             (:CENTER (FLOOR # 2))
;             (T 0))))
; --> LET LET IF <= IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a (INTEGER -13835058055282163711 9223372036854775806), not a FIXNUM.

;     (MAX OPAL::*CURSOR-HALF-WIDTH*
;          (MIN OPAL::MAX-CURSOR-OFFSET
;               (+
;                (MAX (MIN OPAL::MAX-CURSOR-OFFSET OPAL::BASE-WIDTH)
;                     OPAL::*CURSOR-HALF-WIDTH*)
;                (CASE OPAL::JUSTIFICATION (:RIGHT #) (:CENTER #) (T 0)))))
; --> LET LET IF >= IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a (INTEGER -13835058055282163711 4611686018427387903), not a FIXNUM.

;     (+
;      (MAX (MIN OPAL::MAX-CURSOR-OFFSET OPAL::BASE-WIDTH)
;           OPAL::*CURSOR-HALF-WIDTH*)
;      (CASE OPAL::JUSTIFICATION
;        (:RIGHT (- OPAL::MAX-LINE-WIDTH (MAX OPAL::LINE-WIDTH 2)))
;        (:CENTER (FLOOR (- OPAL::MAX-LINE-WIDTH OPAL::LINE-WIDTH) 2))
;        (T 0)))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-+

;     (KR:O-FORMULA
;      (LET ((OPAL::ROOT (KR:GVL :WINDOW)) (OPAL:FONT (KR:GVL :FONT)))
;        (+ (THE FIXNUM (GEM:MAX-CHARACTER-ASCENT OPAL::ROOT OPAL:FONT))
;           (THE FIXNUM (GEM:MAX-CHARACTER-DESCENT OPAL::ROOT OPAL:FONT)))))
; --> KR::O-FORMULA-FN 
; ==>
;   #'(LAMBDA ()
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0) (SPACE 0) (DEBUG 0)))
;       (LET ((OPAL::ROOT (KR:GVL :WINDOW)) (OPAL:FONT (KR:GVL :FONT)))
;         (+ (THE FIXNUM (GEM:MAX-CHARACTER-ASCENT OPAL::ROOT OPAL:FONT))
;            (THE FIXNUM (GEM:MAX-CHARACTER-DESCENT OPAL::ROOT OPAL:FONT)))))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

;     (LENGTH (KR:GVL :CUT-STRINGS))
; 
; 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.

;     (* (KR:GVL-FIXNUM :FONT :FONT-HEIGHT) (LENGTH (KR:GVL :CUT-STRINGS)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 4) because:
;       The result is a (VALUES (INTEGER -21267647932558653948014168890775961600 21267647932558653943402482872348573700) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The result is a (VALUES (INTEGER -21267647932558653948014168890775961600 21267647932558653943402482872348573700) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (LENGTH OPAL::STRUCTS)
; 
; 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/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/objects.lisp
; in: DEFUN CAREFULLY-ERASE
;     (SETQ OPAL::OBJECT-ERASED NIL)
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/basics.lisp
; in: DEFINE-METHOD :INITIALIZE
;     (KR:CALL-PROTOTYPE-METHOD OPAL::GOB)
; --> LOCALLY LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION WHEN IF 
; --> PROGN IF LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN METHOD)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: METHOD is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/aggregates.lisp
; in: DEFINE-METHOD :INITIALIZE
;     (KR:CALL-PROTOTYPE-METHOD OPAL::A-AGGREGATE)
; --> LOCALLY LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION WHEN IF 
; --> PROGN IF LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN METHOD)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: METHOD is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/windows.lisp
; in: DEFINE-METHOD :INITIALIZE
;     (KR:CALL-PROTOTYPE-METHOD OPAL::A-WINDOW)
; --> LOCALLY LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION WHEN IF 
; --> PROGN IF LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN METHOD)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: METHOD is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/windows.lisp
; in: DEFINE-METHOD :DESTROY-ME
;     (KR:CALL-PROTOTYPE-METHOD OPAL::A-WINDOW)
; --> LOCALLY LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION WHEN IF 
; --> PROGN IF LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN METHOD)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: METHOD is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/update.lisp
; in: DEFUN UPDATE-SLOTS-VALUES-CHANGED
;     (LENGTH OPAL::START-SLOT-LIST)
; 
; 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.

;     (AREF OPAL::UPDATE-SLOTS-VALUES OPAL::VALS-INDX)
; ==>
;   (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.

;     (SETF (AREF OPAL::UPDATE-SLOTS-VALUES OPAL::VALS-INDX)
;             (IF (LISTP OPAL::NEW-VALUE)
;                 (COPY-LIST OPAL::NEW-VALUE)
;                 OPAL::NEW-VALUE))
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS ARRAY SB-INT:INDEX
;                                                 SB-C::NEW-VALUE)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

;     (SETF (OPAL::UPDATE-INFO-FORCE-COMPUTATION-P OPAL::OBJ-UPDATE-INFO) NIL)
; --> LET* OPAL::BIT-SETTER IF SETF SB-KERNEL:%INSTANCE-SET 
; ==>
;   (LOGAND (OPAL::UPDATE-INFO-BITS #:OBJECT) -9)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, 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 T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (DOTIMES (OPAL::X OPAL::FIRST-CHANGED)
;       (SETQ OPAL::START-SLOT-LIST (CDR OPAL::START-SLOT-LIST)))
; --> DO BLOCK LET TAGBODY UNLESS IF >= 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 UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.

; --> DO BLOCK LET TAGBODY PSETQ PROGN SETQ THE 1+ 
; ==>
;   (+ OPAL::X 1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/update.lisp
; in: DEFUN SIMPLE-UPDATE-SLOTS-VALUES-CHANGED
;     (AREF OPAL::UPDATE-SLOTS-VALUES OPAL::VALS-INDX)
; ==>
;   (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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/update.lisp
; in: DEFINE-METHOD :UPDATE
;     (OPAL:UPDATE OPAL::CHILD OPAL::CHILD-UPDATE-INFO OPAL::LINE-STYLE-GC
;                  OPAL::FILLING-STYLE-GC OPAL::BBOX-1 OPAL::BBOX-2 OPAL::TOTAL-P)
; --> LET KR:KR-SEND LET* WHEN IF LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN #:G6)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

;     (OPAL:UPDATE OPAL::CHILD OPAL::CHILD-UPDATE-INFO OPAL::BBOX-1 OPAL::BBOX-2
;                  OPAL::TOTAL-P)
; --> LET KR:KR-SEND LET* WHEN IF LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN #:G8)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

;     (SETF (OPAL::UPDATE-INFO-DIRTY-P OPAL::UPDATE-INFO) NIL)
; --> LET* OPAL::BIT-SETTER IF SETF SB-KERNEL:%INSTANCE-SET 
; ==>
;   (LOGAND (OPAL::UPDATE-INFO-BITS #:OBJECT) -2)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, 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 T, 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/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/update.lisp
; in: DEFINE-METHOD :UPDATE
;     (OPAL:DRAW OPAL::GOB OPAL::A-WINDOW)
; --> LET KR:KR-SEND LET* WHEN IF LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN #:G1)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN #:G3)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN #:G6)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN #:G8)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

;     (OPAL::UPDATE-BBOX OPAL::GOB OPAL::OLD-BBOX)
; --> LET SETF SB-KERNEL:%INSTANCE-SET SB-KERNEL:THE* 
; ==>
;   (+ OPAL::LEFT (KR:G-VALUE OPAL::GOB :WIDTH))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, 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 second argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; ==>
;   (+ OPAL::TOP (KR:G-VALUE OPAL::GOB :HEIGHT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, 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 second argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (SETF (OPAL::UPDATE-INFO-DIRTY-P OPAL::UPDATE-INFO) NIL)
; --> LET* OPAL::BIT-SETTER IF SETF SB-KERNEL:%INSTANCE-SET 
; ==>
;   (LOGAND (OPAL::UPDATE-INFO-BITS #:OBJECT) -2)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, 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 T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (OPAL::UPDATE-BBOX OPAL::GOB OPAL::OLD-BBOX)
; --> LET SETF SB-KERNEL:%INSTANCE-SET SB-KERNEL:THE* 
; ==>
;   (+ OPAL::LEFT (KR:G-VALUE OPAL::GOB :WIDTH))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, 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 second argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; ==>
;   (+ OPAL::TOP (KR:G-VALUE OPAL::GOB :HEIGHT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, 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 second argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (SETF (OPAL::UPDATE-INFO-DIRTY-P OPAL::UPDATE-INFO) NIL)
; --> LET* OPAL::BIT-SETTER IF SETF SB-KERNEL:%INSTANCE-SET 
; ==>
;   (LOGAND (OPAL::UPDATE-INFO-BITS #:OBJECT) -2)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, 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 T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (SETF (OPAL::UPDATE-INFO-INVALID-P OPAL::UPDATE-INFO) NIL)
; --> LET* OPAL::BIT-SETTER IF SETF SB-KERNEL:%INSTANCE-SET 
; ==>
;   (LOGAND (OPAL::UPDATE-INFO-BITS #:OBJECT) -5)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, 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 T, 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/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/update-window.lisp
; in: DEFINE-METHOD :UPDATE
;     (OPAL::FIX-UPDATE-SLOTS OPAL::VOB)
; --> LET KR:KR-SEND LET* WHEN IF LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN #:G4)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

;     (DELETE OPAL::CHILD (KR:G-VALUE OPAL::A-WINDOW :CHILD))
; 
; note: unable to convert to EQ test due to type uncertainty: The second argument is a SEQUENCE, not a LIST.

;     (OPAL:UPDATE OPAL::CHILD OPAL::TOTAL-P)
; --> LET KR:KR-SEND LET* WHEN IF LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN #:G36)
; 
; 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/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/multifont.lisp
; in: CREATE-INSTANCE (QUOTE MULTIFONT-LINE)
;     (KR:O-FORMULA (+ (KR:GVL-FIXNUM :ASCENT) (KR:GVL-FIXNUM :DESCENT)))
; --> KR::O-FORMULA-FN 
; ==>
;   #'(LAMBDA ()
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0) (SPACE 0) (DEBUG 0)))
;       (+ (KR:GVL-FIXNUM :ASCENT) (KR:GVL-FIXNUM :DESCENT)))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

;     (KR:O-FORMULA
;      (LET ((OPAL::PREV-LINE (KR:GVL :PREV-LINE)))
;        (IF OPAL::PREV-LINE
;            (+ (KR:GV-FIXNUM OPAL::PREV-LINE :TOP)
;               (KR:GV-FIXNUM OPAL::PREV-LINE :HEIGHT))
;            (KR:GVL :PARENT :TOP))))
; --> KR::O-FORMULA-FN 
; ==>
;   #'(LAMBDA ()
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0) (SPACE 0) (DEBUG 0)))
;       (LET ((OPAL::PREV-LINE (KR:GVL :PREV-LINE)))
;         (IF OPAL::PREV-LINE
;             (+ (KR:GV-FIXNUM OPAL::PREV-LINE :TOP)
;                (KR:GV-FIXNUM OPAL::PREV-LINE :HEIGHT))
;             (KR:GVL :PARENT :TOP))))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/multifont.lisp
; in: CREATE-INSTANCE (QUOTE MULTIFONT-TEXT)
;     (+ (- (KR:GV-FIXNUM OPAL::LAST-LINE :TOP) (KR:GVL-FIXNUM :TOP))
;        (KR:GV-FIXNUM OPAL::LAST-LINE :HEIGHT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES (INTEGER -13835058055282163711 13835058055282163710) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The result is a (VALUES (INTEGER -13835058055282163711 13835058055282163710) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first argument of GENERIC-+

;     (KR:O-FORMULA
;      (LET ((OPAL::CURSOR-LINE (KR:GVL :CURSOR-LINE)))
;        (+ (KR:GV-FIXNUM OPAL::CURSOR-LINE :TOP)
;           (KR:GV-FIXNUM OPAL::CURSOR-LINE :ASCENT))))
; --> KR::O-FORMULA-FN 
; ==>
;   #'(LAMBDA ()
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0) (SPACE 0) (DEBUG 0)))
;       (LET ((OPAL::CURSOR-LINE (KR:GVL :CURSOR-LINE)))
;         (+ (KR:GV-FIXNUM OPAL::CURSOR-LINE :TOP)
;            (KR:GV-FIXNUM OPAL::CURSOR-LINE :ASCENT))))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/multifont.lisp
; in: CREATE-INSTANCE (QUOTE MULTIFONT-TEXT-CURSOR)
;     (KR:O-FORMULA (+ (KR:GVL-FIXNUM :ASCENT) (KR:GVL-FIXNUM :DESCENT)))
; --> KR::O-FORMULA-FN 
; ==>
;   #'(LAMBDA ()
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0) (SPACE 0) (DEBUG 0)))
;       (+ (KR:GVL-FIXNUM :ASCENT) (KR:GVL-FIXNUM :DESCENT)))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

;     (KR:O-FORMULA
;      (LET ((OPAL::PARENT (KR:GVL :PARENT)))
;        (+ (KR:GV-FIXNUM OPAL::PARENT :LEFT)
;           (KR:GV-FIXNUM OPAL::PARENT :CURSOR-X-OFFSET))))
; --> KR::O-FORMULA-FN 
; ==>
;   #'(LAMBDA ()
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0) (SPACE 0) (DEBUG 0)))
;       (LET ((OPAL::PARENT (KR:GVL :PARENT)))
;         (+ (KR:GV-FIXNUM OPAL::PARENT :LEFT)
;            (KR:GV-FIXNUM OPAL::PARENT :CURSOR-X-OFFSET))))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

;     (KR:O-FORMULA (- (KR:GVL-FIXNUM :PARENT :BASE-LINE) (KR:GVL-FIXNUM :ASCENT)))
; --> KR::O-FORMULA-FN 
; ==>
;   #'(LAMBDA ()
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0) (SPACE 0) (DEBUG 0)))
;       (- (KR:GVL-FIXNUM :PARENT :BASE-LINE) (KR:GVL-FIXNUM :ASCENT)))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/multifont.lisp
; in: DEFUN INSTALL-TEXT
;     (KR:O-FORMULA
;      (+ (KR:GVL-FIXNUM :MULTIFONT-LINE :LEFT)
;         (KR:GVL-FIXNUM :MULTIFONT-X-OFFSET)))
; --> KR::O-FORMULA-FN 
; ==>
;   #'(LAMBDA ()
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0) (SPACE 0) (DEBUG 0)))
;       (+ (KR:GVL-FIXNUM :MULTIFONT-LINE :LEFT)
;          (KR:GVL-FIXNUM :MULTIFONT-X-OFFSET)))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/multifont.lisp
; in: DEFINE-METHOD :WRITE-SLOTS
;     (KR:CALL-PROTOTYPE-METHOD OPAL::AGGET OPAL::NORMAL-PROTO OPAL::COMPONENTS
;                               OPAL::BEHAVIORS OPAL::SUPPRESS-CHILDREN?)
; --> LOCALLY LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION WHEN IF 
; --> PROGN IF LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN METHOD)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: METHOD is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/multifont.lisp
; in: DEFINE-METHOD :DRAW
;     (KR:CALL-PROTOTYPE-METHOD OPAL::GOB OPAL::A-WINDOW)
; --> LOCALLY LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION WHEN IF 
; --> PROGN IF LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN METHOD)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: METHOD is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/multifont.lisp
; in: DEFUN ADD-OBJECT
;     (KR:O-FORMULA
;      (+ (KR:GVL-FIXNUM :MULTIFONT-LINE :LEFT)
;         (KR:GVL-FIXNUM :MULTIFONT-X-OFFSET)))
; --> KR::O-FORMULA-FN 
; ==>
;   #'(LAMBDA ()
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0) (SPACE 0) (DEBUG 0)))
;       (+ (KR:GVL-FIXNUM :MULTIFONT-LINE :LEFT)
;          (KR:GVL-FIXNUM :MULTIFONT-X-OFFSET)))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/virtual-aggregates.lisp
; in: DEFINE-METHOD :INITIALIZE
;     (KR:CALL-PROTOTYPE-METHOD OPAL::GOB)
; --> LOCALLY LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION WHEN IF 
; --> PROGN IF LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN METHOD)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: METHOD is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/virtual-aggregates.lisp
; in: DEFINE-METHOD :DESTROY-ME
;     (KR:CALL-PROTOTYPE-METHOD OPAL::GOB OPAL::TOP-LEVEL-P)
; --> LOCALLY LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION WHEN IF 
; --> PROGN IF LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN METHOD)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: METHOD is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/pixmaps.lisp
; in: DEFUN RUN-READ-XPM-FILE
;     (DECF OPAL::WIDTH OPAL::LEFT-PAD)
; --> SETQ THE SB-IMPL::XSUBTRACT 
; ==>
;   OPAL::LEFT-PAD
; 
; note: deleting unreachable code

;     (DECF (GETF OPAL::PROPERTIES :X-HOT) OPAL::LEFT-PAD)
; --> LET* LET SB-IMPL::%PUTF 
; ==>
;   OPAL::PROPERTIES
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/opal/pixmaps.lisp
; in: DEFUN READ-XPM-FILE
;     (DECF OPAL::WIDTH OPAL::LEFT-PAD)
; --> SETQ THE SB-IMPL::XSUBTRACT 
; ==>
;   OPAL::LEFT-PAD
; 
; note: deleting unreachable code

;     (DECF (GETF OPAL::PROPERTIES :X-HOT) OPAL::LEFT-PAD)
; --> LET* LET SB-IMPL::%PUTF 
; ==>
;   OPAL::PROPERTIES
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/inter/i-windows.lisp
; in: DEFINE-METHOD :DESTROY-ME
;     (KR:CALL-PROTOTYPE-METHOD INTERACTORS::WINDOW)
; --> LOCALLY LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION WHEN IF 
; --> PROGN IF LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN METHOD)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: METHOD is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-garnet/4326dd1bbf446e76457831d1bc1bf2befb6cf0d4/cl-garnet-20180125-git/src/inter/i-windows.lisp
; in: DEFINE-METHOD :INITIALIZE
;     (KR:CALL-PROTOTYPE-METHOD INTERACTORS::WINDOW)
; --> LOCALLY LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION WHEN IF 
; --> PROGN IF LET FUNCALL SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN METHOD)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: METHOD is not known to be a function
; 
; compilation unit aborted
;   caught 1 fatal ERROR condition
;   caught 2 STYLE-WARNING conditions
;   printed 523 notes