lisp-binary

SBCL 1.4.3 / ASDF 3.3.1

lisp-binary

WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/flexi-streams/d08cfa551a2f185431304236cd56db2fbb98b864/flexi-streams-20180131-git/flexi-streams.asd" contains definition for system "flexi-streams-test". Please only define "flexi-streams" and secondary systems with a name starting with "flexi-streams/" (e.g. "flexi-streams/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/quasiquote-2.0/5f61d74c96a9a863f38ab56c08b5287187bd9ef7/quasiquote-2.0-20180131-git/quasiquote-2.0.asd" contains definition for system "quasiquote-2.0-tests". Please only define "quasiquote-2.0" and secondary systems with a name starting with "quasiquote-2.0/" (e.g. "quasiquote-2.0/test") in that file.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/integer.lisp
; in: DEFUN DECODE-MSB
;     (DEFUN LISP-BINARY/INTEGER:DECODE-MSB (LISP-BINARY/INTEGER::BYTES)
;       (LISP-BINARY/INTEGER:DECODE-LSB (REVERSE LISP-BINARY/INTEGER::BYTES)))
; --> PROGN 
; ==>
;   (SB-IMPL::%DEFUN 'LISP-BINARY/INTEGER:DECODE-MSB
;                    (SB-INT:NAMED-LAMBDA LISP-BINARY/INTEGER:DECODE-MSB
;                        (LISP-BINARY/INTEGER::BYTES)
;                      (BLOCK LISP-BINARY/INTEGER:DECODE-MSB
;                        (LISP-BINARY/INTEGER:DECODE-LSB
;                         (REVERSE LISP-BINARY/INTEGER::BYTES))))
;                    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Call to LISP-BINARY/INTEGER:DECODE-LSB could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/integer.lisp
; in: DEFUN ENCODE-MSB
;     (DEFUN LISP-BINARY/INTEGER:ENCODE-MSB (NUMBER LISP-BINARY/INTEGER::BYTES)
;       (DECLARE (TYPE INTEGER NUMBER))
;       (REVERSE
;        (LISP-BINARY/INTEGER:ENCODE-LSB NUMBER LISP-BINARY/INTEGER::BYTES)))
; --> PROGN 
; ==>
;   (SB-IMPL::%DEFUN 'LISP-BINARY/INTEGER:ENCODE-MSB
;                    (SB-INT:NAMED-LAMBDA LISP-BINARY/INTEGER:ENCODE-MSB
;                        (NUMBER LISP-BINARY/INTEGER::BYTES)
;                      (DECLARE (TYPE INTEGER NUMBER))
;                      (BLOCK LISP-BINARY/INTEGER:ENCODE-MSB
;                        (REVERSE
;                         (LISP-BINARY/INTEGER:ENCODE-LSB NUMBER
;                          LISP-BINARY/INTEGER::BYTES))))
;                    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Call to LISP-BINARY/INTEGER:ENCODE-LSB could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/integer.lisp
; in: DEFUN WRITE-INTEGER
;     (DEFUN LISP-BINARY/INTEGER:WRITE-INTEGER
;            (NUMBER LISP-BINARY/INTEGER::SIZE STREAM
;             &KEY (LISP-BINARY/INTEGER::BYTE-ORDER :LITTLE-ENDIAN)
;             LISP-BINARY/INTEGER::SIGNED)
;       (WHEN LISP-BINARY/INTEGER::SIGNED
;         (SETF NUMBER
;                 (LISP-BINARY/INTEGER:SIGNED->UNSIGNED NUMBER
;                  LISP-BINARY/INTEGER::SIZE)))
;       (COND
;        ((INTEGERP LISP-BINARY/INTEGER::SIZE)
;         (LISP-BINARY/INTEGER:WRITE-BYTES
;          (ECASE LISP-BINARY/INTEGER::BYTE-ORDER # # #) STREAM))
;        (T
;         (LET* (# #)
;           (LISP-BINARY/INTEGER:WRITE-BYTES LISP-BINARY/INTEGER::TOO-BIG STREAM
;            LISP-BINARY/INTEGER::SIZE)))))
; --> PROGN 
; ==>
;   (SB-IMPL::%DEFUN 'LISP-BINARY/INTEGER:WRITE-INTEGER
;                    (SB-INT:NAMED-LAMBDA LISP-BINARY/INTEGER:WRITE-INTEGER
;                        (NUMBER LISP-BINARY/INTEGER::SIZE STREAM &KEY
;                         (LISP-BINARY/INTEGER::BYTE-ORDER :LITTLE-ENDIAN)
;                         LISP-BINARY/INTEGER::SIGNED)
;                      (BLOCK LISP-BINARY/INTEGER:WRITE-INTEGER
;                        (WHEN LISP-BINARY/INTEGER::SIGNED (SETF #))
;                        (COND (# #) (T #))))
;                    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Call to LISP-BINARY/INTEGER:ENCODE-MSB could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/integer.lisp
; in: DEFUN READ-INTEGER
;     (ASH LISP-BINARY/INTEGER::INT LISP-BINARY/INTEGER::EXTRA-BITS)
; ==>
;   LISP-BINARY/INTEGER::INT
; 
; note: deleting unreachable code

;     (ASH LISP-BINARY/INTEGER::PARTIAL-BYTE (* (FLOOR LENGTH) 8))
; ==>
;   LISP-BINARY/INTEGER::PARTIAL-BYTE
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

;     (DEFUN LISP-BINARY/INTEGER:READ-INTEGER
;            (LENGTH STREAM
;             &KEY (LISP-BINARY/INTEGER::BYTE-ORDER :LITTLE-ENDIAN)
;             LISP-BINARY/INTEGER::SIGNED)
;       "Reads an integer of LENGTH bytes from the STREAM in the specified BYTE-ORDER.
;   
;   If SIGNED is non-NIL, the number is interpreted as being in two's complement format.
;   
;   If the STREAM is a BIT-STREAM, then the LENGTH doesn't have to be an integer."
;       (MULTIPLE-VALUE-BIND
;           (LISP-BINARY/INTEGER::BYTES LISP-BINARY/INTEGER::BYTES-READ)
;           (LISP-BINARY/INTEGER:READ-BYTES LENGTH STREAM)
;         (LET ((LISP-BINARY/INTEGER::BYTES #)
;               (LISP-BINARY/INTEGER::PARTIAL-BYTE #)
;               (LISP-BINARY/INTEGER::EXTRA-BITS #))
;           (LABELS (# # #)
;             (DECLARE #)
;             (VALUES # LISP-BINARY/INTEGER::BYTES-READ)))))
; --> PROGN 
; ==>
;   (SB-IMPL::%DEFUN 'LISP-BINARY/INTEGER:READ-INTEGER
;                    (SB-INT:NAMED-LAMBDA LISP-BINARY/INTEGER:READ-INTEGER
;                        (LENGTH STREAM &KEY
;                                (LISP-BINARY/INTEGER::BYTE-ORDER :LITTLE-ENDIAN)
;                                LISP-BINARY/INTEGER::SIGNED)
;                      "Reads an integer of LENGTH bytes from the STREAM in the specified BYTE-ORDER.
; 
; If SIGNED is non-NIL, the number is interpreted as being in two's complement format.
; 
; If the STREAM is a BIT-STREAM, then the LENGTH doesn't have to be an integer."
;                      (BLOCK LISP-BINARY/INTEGER:READ-INTEGER
;                        (MULTIPLE-VALUE-BIND
;                            (LISP-BINARY/INTEGER::BYTES
;                             LISP-BINARY/INTEGER::BYTES-READ)
;                            (LISP-BINARY/INTEGER:READ-BYTES LENGTH STREAM)
;                          (LET #
;                            #))))
;                    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Call to LISP-BINARY/INTEGER:DECODE-MSB could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "lisp-binary" "integer">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFVAR +INF
;     (CFFI:MEM-REF LISP-BINARY/FLOAT::PTR :DOUBLE)
; --> CFFI-SYS:%MEM-REF 
; ==>
;   (SB-SYS:SAP-REF-DOUBLE LISP-BINARY/FLOAT::PTR 0)
; 
; note: doing float to pointer coercion (cost 13)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFVAR -INF
;     (CFFI:MEM-REF LISP-BINARY/FLOAT::PTR :DOUBLE)
; --> CFFI-SYS:%MEM-REF 
; ==>
;   (SB-SYS:SAP-REF-DOUBLE LISP-BINARY/FLOAT::PTR 0)
; 
; note: doing float to pointer coercion (cost 13)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFVAR QUIET-NAN
;     (CFFI:MEM-REF LISP-BINARY/FLOAT::PTR :DOUBLE)
; --> CFFI-SYS:%MEM-REF 
; ==>
;   (SB-SYS:SAP-REF-DOUBLE LISP-BINARY/FLOAT::PTR 0)
; 
; note: doing float to pointer coercion (cost 13)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN FLOAT-VALUE
;     (EXPT -1 LISP-BINARY/FLOAT::SIGN)
; 
; note: unable to recode as an ODDP check due to type uncertainty: The second argument is a NUMBER, not a INTEGER.

;     (* (EXPT -1 LISP-BINARY/FLOAT::SIGN) LISP-BINARY/FLOAT::SIGNIFICAND
;        (EXPT LISP-BINARY/FLOAT::BASE LISP-BINARY/FLOAT::EXPONENT))
; --> * 
; ==>
;   (* (EXPT -1 LISP-BINARY/FLOAT::SIGN) LISP-BINARY/FLOAT::SIGNIFICAND)
; 
; 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.

;     (EXPT LISP-BINARY/FLOAT::BASE LISP-BINARY/FLOAT::EXPONENT)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (SINGLE-FLOAT 0.0).The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (DOUBLE-FLOAT 0.0d0).The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (SINGLE-FLOAT 0.0).The second argument is a NUMBER, not a (SIGNED-BYTE 32).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (DOUBLE-FLOAT 0.0d0).The second argument is a NUMBER, not a (SIGNED-BYTE 32).

;     (* (EXPT -1 LISP-BINARY/FLOAT::SIGN) LISP-BINARY/FLOAT::SIGNIFICAND
;        (EXPT LISP-BINARY/FLOAT::BASE LISP-BINARY/FLOAT::EXPONENT))
; ==>
;   (* (* (EXPT -1 LISP-BINARY/FLOAT::SIGN) LISP-BINARY/FLOAT::SIGNIFICAND)
;      (EXPT LISP-BINARY/FLOAT::BASE LISP-BINARY/FLOAT::EXPONENT))
; 
; 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.

; --> * 
; ==>
;   (* (EXPT -1 LISP-BINARY/FLOAT::SIGN) LISP-BINARY/FLOAT::SIGNIFICAND)
; 
; 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 T, 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 T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; ==>
;   (* (* (EXPT -1 LISP-BINARY/FLOAT::SIGN) LISP-BINARY/FLOAT::SIGNIFICAND)
;      (EXPT LISP-BINARY/FLOAT::BASE LISP-BINARY/FLOAT::EXPONENT))
; 
; 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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN CALCULATE-EXPONENT
;     (EXPT -1 LISP-BINARY/FLOAT::SIGN)
; 
; note: unable to recode as an ODDP check due to type uncertainty: The second argument is a NUMBER, not a INTEGER.

;     (* LISP-BINARY/FLOAT::FRACTION (EXPT -1 LISP-BINARY/FLOAT::SIGN))
; 
; 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.

;     (/ (* LISP-BINARY/FLOAT::FRACTION (EXPT -1 LISP-BINARY/FLOAT::SIGN))
;        LISP-BINARY/FLOAT::SIGNIFICAND)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; 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.

;     (LOG
;      (/ (* LISP-BINARY/FLOAT::FRACTION (EXPT -1 LISP-BINARY/FLOAT::SIGN))
;         LISP-BINARY/FLOAT::SIGNIFICAND))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The result is a (VALUES (OR SINGLE-FLOAT DOUBLE-FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.The result is a (VALUES (OR SINGLE-FLOAT DOUBLE-FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (/
;      (LOG
;       (/ (* LISP-BINARY/FLOAT::FRACTION (EXPT -1 LISP-BINARY/FLOAT::SIGN))
;          LISP-BINARY/FLOAT::SIGNIFICAND))
;      (LOG 2))
; 
; note: unable to convert to multiplication by reciprocal due to type uncertainty: The first argument is a (OR SINGLE-FLOAT DOUBLE-FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.

;     (FLOOR
;      (/
;       (LOG (/ (* LISP-BINARY/FLOAT::FRACTION #) LISP-BINARY/FLOAT::SIGNIFICAND))
;       (LOG 2)))
; --> 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 FLOAT, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a FLOAT, not a DOUBLE-FLOAT.

; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF NOT IF 
; --> ZEROP = = IF = 
; ==>
;   (FLOAT SB-C::Y SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The second argument is a FLOAT, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The second argument is a FLOAT, not a DOUBLE-FLOAT.

; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF 
; --> MINUSP < < IF < 
; ==>
;   (FLOAT SB-C::Y SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The second argument is a FLOAT, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The second argument is a FLOAT, not a DOUBLE-FLOAT.

;     (* LISP-BINARY/FLOAT::FRACTION (EXPT -1 LISP-BINARY/FLOAT::SIGN))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (/ (* LISP-BINARY/FLOAT::FRACTION (EXPT -1 LISP-BINARY/FLOAT::SIGN))
;        LISP-BINARY/FLOAT::SIGNIFICAND)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (/
;      (LOG
;       (/ (* LISP-BINARY/FLOAT::FRACTION (EXPT -1 LISP-BINARY/FLOAT::SIGN))
;          LISP-BINARY/FLOAT::SIGNIFICAND))
;      (LOG 2))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (OR SINGLE-FLOAT DOUBLE-FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT) DOUBLE-FLOAT SINGLE-FLOAT) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (OR SINGLE-FLOAT DOUBLE-FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT) DOUBLE-FLOAT SINGLE-FLOAT) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).

;     (FLOOR
;      (/
;       (LOG (/ (* LISP-BINARY/FLOAT::FRACTION #) LISP-BINARY/FLOAT::SIGNIFICAND))
;       (LOG 2)))
; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF NOT IF 
; --> ZEROP = = IF 
; ==>
;   (= SB-C::X (FLOAT SB-C::Y SB-C::X))
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a FLOAT, not a DOUBLE-FLOAT.
;       The second argument is a FLOAT, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a FLOAT, not a SINGLE-FLOAT.
;       The second argument is a FLOAT, not a SINGLE-FLOAT.

; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF 
; --> MINUSP < < IF 
; ==>
;   (< SB-C::X (FLOAT SB-C::Y SB-C::X))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a FLOAT, not a SINGLE-FLOAT.
;       The second argument is a FLOAT, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a FLOAT, not a DOUBLE-FLOAT.
;       The second argument is a FLOAT, not a DOUBLE-FLOAT.

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN NANP
;     (COERCE LISP-BINARY/FLOAT::DECODED-VALUE 'DOUBLE-FLOAT)
; --> THE 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN INFINITYP
;     (COERCE LISP-BINARY/FLOAT::DECODED-VALUE 'DOUBLE-FLOAT)
; --> THE 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.

;     (> LISP-BINARY/FLOAT::DECODED-VALUE 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (COERCE LISP-BINARY/FLOAT::DECODED-VALUE 'DOUBLE-FLOAT)
; --> THE 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::X)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).

;     (> LISP-BINARY/FLOAT::DECODED-VALUE 0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN GET-FORMAT
;     (ASSOC FORMAT LISP-BINARY/FLOAT::*FORMAT-TABLE*)
; ==>
;   (SB-KERNEL:%ASSOC 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/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN FORMAT-SIZE
;     (/ (+ LISP-BINARY/FLOAT::SOME-BITS LISP-BINARY/FLOAT::MORE-BITS) 8)
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.

;     (+ LISP-BINARY/FLOAT::SOME-BITS LISP-BINARY/FLOAT::MORE-BITS)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN GET-EXPONENT
;     (- (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 1))
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 1)))
; 
; note: unable to Eliminate %negate/%negate of rationals due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (- (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS) 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.

;     (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (- (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 1))
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 1)))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       etc.

;     (ASH INTEGER (- (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 1)))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOGAND (- (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS) 1)
;             (ASH INTEGER (- (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 1))))
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -1), not a FIXNUM.
;       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 3) because:
;       The first argument is a (INTEGER -1), not a (SIGNED-BYTE 64).
;       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.

;     (-
;      (LOGAND (- (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS) 1)
;              (ASH INTEGER (- (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 1))))
;      LISP-BINARY/FLOAT::EXPONENT-BIAS)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a 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 first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN GET-SIGNIFICAND
;     (ASH 1 LISP-BINARY/FLOAT::SIGNIFICAND-BITS)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (- (ASH 1 LISP-BINARY/FLOAT::SIGNIFICAND-BITS) 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.

;     (LOGAND (- (ASH 1 LISP-BINARY/FLOAT::SIGNIFICAND-BITS) 1) INTEGER)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -1), not a FIXNUM.
;       The second 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 3) because:
;       The first argument is a (INTEGER -1), not a (SIGNED-BYTE 64).
;       The second 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/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN EXPONENT-ALL-ONES-P
;     (=
;      (LISP-BINARY/FLOAT::GET-EXPONENT INTEGER LISP-BINARY/FLOAT::SIGNIFICAND-BITS
;                                       LISP-BINARY/FLOAT::EXPONENT-BITS 0)
;      (1- (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS)))
; 
; 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.

;     (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (1- (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS))
; ==>
;   (- (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS) 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/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN %INFINITYP
;     (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)
; ==>
;   (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN %QNANP
;     (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)
; ==>
;   (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 2)
; 
; 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.

;     (ASH 1 (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 2))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (= LISP-BINARY/FLOAT::SIGNIFICAND
;        (ASH 1 (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 2)))
; --> EQL IF EQL SB-KERNEL:%EQL/INTEGER IF 
; ==>
;   (SB-KERNEL:%EQL/INTEGER SB-C::X SB-C::Y)
; 
; note: forced to do %EQL/INTEGER (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN %SNANP
;     (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)
; ==>
;   (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 3)
; 
; 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.

;     (ASH 1 (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 3))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (= LISP-BINARY/FLOAT::SIGNIFICAND
;        (ASH 1 (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 3)))
; --> EQL IF EQL SB-KERNEL:%EQL/INTEGER IF 
; ==>
;   (SB-KERNEL:%EQL/INTEGER SB-C::X SB-C::Y)
; 
; note: forced to do %EQL/INTEGER (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN DECODE-SIGNIFICAND
;     (= 0 LISP-BINARY/FLOAT::RAW-EXPONENT)
; 
; 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.

;     (LOOP LISP-BINARY/FLOAT::FOR LISP-BINARY/FLOAT::I LISP-BINARY/FLOAT::FROM (1-
;                                                                                LISP-BINARY/FLOAT::SIGNIFICAND-BITS) LISP-BINARY/FLOAT::DOWNTO 0
;           LISP-BINARY/FLOAT::FOR BIT = (LISP-BINARY/FLOAT::POPBIT
;                                         LISP-BINARY/FLOAT::SIGNIFICAND)
;           LISP-BINARY/FLOAT::SUM ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY WHEN IF 
; ==>
;   (< LISP-BINARY/FLOAT::I '0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (- LISP-BINARY/FLOAT::I)
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER LISP-BINARY/FLOAT::I))
; 
; note: unable to Eliminate %negate/%negate of rationals due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (EXPT 2 (- LISP-BINARY/FLOAT::I))
; 
; note: unable to optimize due to type uncertainty: The second argument is a REAL, not a INTEGER.
; 
; note: unable to optimize due to type uncertainty: The second argument is a REAL, not a UNSIGNED-BYTE.

;     (* BIT (EXPT 2 (- LISP-BINARY/FLOAT::I)))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (RATIONAL 0) (SINGLE-FLOAT 0.0)), not a INTEGER.

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

;     (ASH 1 (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOGIOR (ASH 1 (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS))
;             LISP-BINARY/FLOAT::SIGNIFICAND)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second 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.

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

;     (LOOP LISP-BINARY/FLOAT::FOR LISP-BINARY/FLOAT::I LISP-BINARY/FLOAT::FROM (1-
;                                                                                LISP-BINARY/FLOAT::SIGNIFICAND-BITS) LISP-BINARY/FLOAT::DOWNTO 0
;           LISP-BINARY/FLOAT::FOR BIT = (LISP-BINARY/FLOAT::POPBIT
;                                         LISP-BINARY/FLOAT::SIGNIFICAND)
;           LISP-BINARY/FLOAT::SUM ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY WHEN IF 
; ==>
;   (< LISP-BINARY/FLOAT::I '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.

;     (LISP-BINARY/FLOAT::POPBIT LISP-BINARY/FLOAT::SIGNIFICAND)
; --> PROG1 LET SETF SETQ THE 
; ==>
;   (ASH LISP-BINARY/FLOAT::SIGNIFICAND -1)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.

;     (- LISP-BINARY/FLOAT::I)
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER LISP-BINARY/FLOAT::I))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first 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 1) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (* BIT (EXPT 2 (- LISP-BINARY/FLOAT::I)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 4) because:
;       The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (RATIONAL 0) (SINGLE-FLOAT 0.0)), not a FIXNUM.
;       The result is a (VALUES (OR (SINGLE-FLOAT 0.0) (RATIONAL 0) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (RATIONAL 0) (SINGLE-FLOAT 0.0)), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (OR (SINGLE-FLOAT 0.0) (RATIONAL 0) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (LOOP LISP-BINARY/FLOAT::FOR LISP-BINARY/FLOAT::I LISP-BINARY/FLOAT::FROM (1-
;                                                                                LISP-BINARY/FLOAT::SIGNIFICAND-BITS) LISP-BINARY/FLOAT::DOWNTO 0
;           LISP-BINARY/FLOAT::FOR BIT = (LISP-BINARY/FLOAT::POPBIT
;                                         LISP-BINARY/FLOAT::SIGNIFICAND)
;           LISP-BINARY/FLOAT::SUM ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-226 (* BIT (EXPT 2 (- LISP-BINARY/FLOAT::I))))
; 
; 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 (OR (SINGLE-FLOAT 0.0) (RATIONAL 0) (DOUBLE-FLOAT 0.0d0)), 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 (OR (SINGLE-FLOAT 0.0) (RATIONAL 0) (DOUBLE-FLOAT 0.0d0)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SB-LOOP::LOOP-DESETQ 
; --> SETQ THE 1- 
; ==>
;   (- LISP-BINARY/FLOAT::I 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/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN EXPONENT-ZERO-P
;     (ZEROP
;      (LISP-BINARY/FLOAT::GET-EXPONENT INTEGER LISP-BINARY/FLOAT::SIGNIFICAND-BITS
;                                       LISP-BINARY/FLOAT::EXPONENT-BITS 0))
; --> = IF 
; ==>
;   (=
;    (LISP-BINARY/FLOAT::GET-EXPONENT INTEGER LISP-BINARY/FLOAT::SIGNIFICAND-BITS
;                                     LISP-BINARY/FLOAT::EXPONENT-BITS 0)
;    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/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN DECODE-FLOAT-BITS/ARITHMETIC
;     (- (1- LISP-BINARY/FLOAT::EXPONENT-BIAS))
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (1- LISP-BINARY/FLOAT::EXPONENT-BIAS)))
; 
; note: unable to Eliminate %negate/%negate of rationals due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 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.

;     (+ (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 1) LISP-BINARY/FLOAT::EXPONENT-BITS)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The 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.

;     (-
;      (+ (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 1)
;         LISP-BINARY/FLOAT::EXPONENT-BITS))
; ==>
;   (SB-KERNEL:%NEGATE
;    (THE NUMBER
;         (+ (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 1)
;            LISP-BINARY/FLOAT::EXPONENT-BITS)))
; 
; note: forced to do GENERIC-NEGATE (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 (signed-byte 64) arithmetic (cost 2) 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.

;     (ASH INTEGER
;          (-
;           (+ (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 1)
;              LISP-BINARY/FLOAT::EXPONENT-BITS)))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)
; ==>
;   (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 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.

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

;     (- (1- LISP-BINARY/FLOAT::EXPONENT-BIAS))
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (1- LISP-BINARY/FLOAT::EXPONENT-BIAS)))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN MAKE-LARGEST-DENORMAL
;     (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)
; ==>
;   (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (ASH 1 (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (1- (ASH 1 (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)))
; ==>
;   (- (ASH 1 (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)) 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/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN DENORMALP
;     (ASSOC FORMAT LISP-BINARY/FLOAT::*DENORMALS*)
; ==>
;   (SB-KERNEL:%ASSOC 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))

;     (ABS NUMBER)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (< LISP-BINARY/FLOAT::SMALLEST (ABS NUMBER) LISP-BINARY/FLOAT::LARGEST)
; --> 
; --> (LAMBDA (#:G3 #:G2 #:G1) (DECLARE (TYPE REAL #:G3 #:G2 #:G1)) (IF (< #:G3 #:G2) (IF (< #:G2 #:G1) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 
; ==>
;   (< #:G3 #:G2)
; 
; 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 (OR (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0) (RATIONAL 0)), not a RATIONAL.

; --> 
; --> (LAMBDA (#:G3 #:G2 #:G1) (DECLARE (TYPE REAL #:G3 #:G2 #:G1)) (IF (< #:G3 #:G2) (IF (< #:G2 #:G1) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF IF 
; ==>
;   (< #:G2 #:G1)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0) (RATIONAL 0)), not a FLOAT.The second argument is a REAL, not a RATIONAL.

;     (ABS NUMBER)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).

;     (< LISP-BINARY/FLOAT::SMALLEST (ABS NUMBER) LISP-BINARY/FLOAT::LARGEST)
; --> 
; --> (LAMBDA (#:G3 #:G2 #:G1) (DECLARE (TYPE REAL #:G3 #:G2 #:G1)) (IF (< #:G3 #:G2) (IF (< #:G2 #:G1) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 
; ==>
;   (< #:G3 #:G2)
; 
; 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 (OR (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0) (RATIONAL 0)), 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 (OR (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0) (RATIONAL 0)), not a DOUBLE-FLOAT.
;       etc.

; --> 
; --> (LAMBDA (#:G3 #:G2 #:G1) (DECLARE (TYPE REAL #:G3 #:G2 #:G1)) (IF (< #:G3 #:G2) (IF (< #:G2 #:G1) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF IF 
; ==>
;   (< #:G2 #:G1)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0) (RATIONAL 0)), 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 (OR (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0) (RATIONAL 0)), not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN ENCODE-SIGNIFICAND
;     (>= LISP-BINARY/FLOAT::SIGNIFICAND LISP-BINARY/FLOAT::POWER-OF-TWO)
; --> 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.

; --> 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 LISP-BINARY/FLOAT::FOR LISP-BINARY/FLOAT::B LISP-BINARY/FLOAT::FROM 0 LISP-BINARY/FLOAT::TO LISP-BINARY/FLOAT::SIGNIFICAND-BITS
;           LISP-BINARY/FLOAT::FOR LISP-BINARY/FLOAT::POWER-OF-TWO = (EXPT 2
;                                                                          (-
;                                                                           LISP-BINARY/FLOAT::B))
;           IF ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY WHEN IF 
; ==>
;   (> LISP-BINARY/FLOAT::B #:LOOP-LIMIT-0)
; 
; 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 REAL, not a FIXNUM.

;     (- LISP-BINARY/FLOAT::B)
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER LISP-BINARY/FLOAT::B))
; 
; note: forced to do GENERIC-NEGATE (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 * 0) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER * 0) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (EXPT 2 (- LISP-BINARY/FLOAT::B))
; --> LET ASH ABS IF 
; ==>
;   (< SB-C::X 0)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a (INTEGER * 0), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER * 0), not a FIXNUM.
;       etc.

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

; --> LET 
; ==>
;   (ASH 1 (ABS SB-C::POWER))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; --> LET IF MINUSP 
; ==>
;   (< SB-C::POWER 0)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a (INTEGER * 0), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER * 0), not a FIXNUM.
;       etc.

;     (>= LISP-BINARY/FLOAT::SIGNIFICAND LISP-BINARY/FLOAT::POWER-OF-TWO)
; --> OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a (RATIONAL 0 1), not a FIXNUM.

;     (DECF LISP-BINARY/FLOAT::SIGNIFICAND LISP-BINARY/FLOAT::POWER-OF-TWO)
; --> SETQ THE SB-IMPL::XSUBTRACT BLOCK 
; ==>
;   (- SB-IMPL::B SB-IMPL::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a (RATIONAL 0 1), 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 (RATIONAL 0 1), not a (SIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS LISP-BINARY/FLOAT::B)
; 
; 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 UNSIGNED-BYTE, 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 UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (ASH 1 (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS LISP-BINARY/FLOAT::B))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a REAL, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a REAL, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP LISP-BINARY/FLOAT::FOR LISP-BINARY/FLOAT::B LISP-BINARY/FLOAT::FROM 0 LISP-BINARY/FLOAT::TO LISP-BINARY/FLOAT::SIGNIFICAND-BITS
;           LISP-BINARY/FLOAT::FOR LISP-BINARY/FLOAT::POWER-OF-TWO = (EXPT 2
;                                                                          (-
;                                                                           LISP-BINARY/FLOAT::B))
;           IF ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY IF PROGN SETQ THE 
; ==>
;   (+ #:LOOP-SUM-1
;      (ASH 1 (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS LISP-BINARY/FLOAT::B)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The second argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SB-LOOP::LOOP-DESETQ 
; --> SETQ THE 1+ 
; ==>
;   (+ LISP-BINARY/FLOAT::B 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.

;     (ASH
;      (LOOP LISP-BINARY/FLOAT::FOR LISP-BINARY/FLOAT::B LISP-BINARY/FLOAT::FROM 0 LISP-BINARY/FLOAT::TO LISP-BINARY/FLOAT::SIGNIFICAND-BITS
;            LISP-BINARY/FLOAT::FOR LISP-BINARY/FLOAT::POWER-OF-TWO = (EXPT 2
;                                                                           (-
;                                                                            LISP-BINARY/FLOAT::B))
;            IF ...)
;      -1)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN %MAKE-INFINITY
;     (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)
; ==>
;   (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (+ (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS) LISP-BINARY/FLOAT::EXPONENT-BITS)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (ASH
;      (IF LISP-BINARY/FLOAT::POSITIVEP
;          0
;          1)
;      (+ (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)
;         LISP-BINARY/FLOAT::EXPONENT-BITS))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (1- (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS))
; ==>
;   (- (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS) 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.

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

;     (ASH (1- (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS))
;          (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER -1), not a FIXNUM.
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER -1), not a FIXNUM.
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOGIOR
;      (ASH
;       (IF LISP-BINARY/FLOAT::POSITIVEP
;           0
;           1)
;       (+ (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)
;          LISP-BINARY/FLOAT::EXPONENT-BITS))
;      (ASH (1- (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS))
;           (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)))
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       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 (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN %MAKE-QUIET-NAN
;     (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (1- (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS))
; ==>
;   (- (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS) 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.

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

;     (ASH (1- (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS))
;          (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER -1), not a FIXNUM.
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER -1), not a FIXNUM.
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 2)
; 
; 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.

;     (ASH 1 (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 2))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOGIOR
;      (ASH (1- (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS))
;           (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS))
;      (ASH 1 (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 2)))
; 
; 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 second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a UNSIGNED-BYTE, 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/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN %MAKE-SIGNALLING-NAN
;     (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (1- (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS))
; ==>
;   (- (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS) 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.

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

;     (ASH (1- (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS))
;          (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER -1), not a FIXNUM.
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER -1), not a FIXNUM.
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 3)
; 
; 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.

;     (ASH 1 (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 3))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOGIOR
;      (ASH (1- (ASH 1 LISP-BINARY/FLOAT::EXPONENT-BITS))
;           (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS))
;      (ASH 1 (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS 3)))
; 
; 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 second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a UNSIGNED-BYTE, 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/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN CALCULATE-SIGNIFICAND
;     (FLOOR LISP-BINARY/FLOAT::FRACTION)
; --> 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.

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

; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 
; ==>
;   (+ REM SB-C::DIVISOR)
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT), not a RATIONAL.

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

;     (1+ (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS LISP-BINARY/FLOAT::BITS-CONSUMED))
; ==>
;   (+ (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS LISP-BINARY/FLOAT::BITS-CONSUMED) 1)
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (LOOP LISP-BINARY/FLOAT::FOR BIT LISP-BINARY/FLOAT::DOWNFROM (-
;                                                                   LISP-BINARY/FLOAT::SIGNIFICAND-BITS
;                                                                   (INCF
;                                                                    LISP-BINARY/FLOAT::BITS-CONSUMED))
;           LISP-BINARY/FLOAT::REPEAT (1+
;                                      (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS
;                                         LISP-BINARY/FLOAT::BITS-CONSUMED))
;           LISP-BINARY/FLOAT::SUM (MULTIPLE-VALUE-BIND
;                                      (LISP-BINARY/FLOAT::INT
;                                       LISP-BINARY/FLOAT::FRAC)
;                                      (FLOOR (* LISP-BINARY/FLOAT::FRAC-PART 2))
;                                    (SETF LISP-BINARY/FLOAT::FRAC-PART
;                                            LISP-BINARY/FLOAT::FRAC)
;                                    (ASH LISP-BINARY/FLOAT::INT BIT)))
; --> BLOCK LET LET CEILING CEILING 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.

; --> BLOCK LET LET CEILING CEILING 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.

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

;     (* LISP-BINARY/FLOAT::FRAC-PART 2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (RATIONAL 0 (1)) DOUBLE-FLOAT SINGLE-FLOAT), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (RATIONAL 0 (1)) DOUBLE-FLOAT SINGLE-FLOAT), not a DOUBLE-FLOAT.
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a (OR (RATIONAL 0 (1)) DOUBLE-FLOAT SINGLE-FLOAT), not a INTEGER.
; 
; note: unable to associate */(* /) of constants due to type uncertainty: The first argument is a (OR (RATIONAL 0 (1)) DOUBLE-FLOAT SINGLE-FLOAT), not a RATIONAL.

;     (FLOOR (* LISP-BINARY/FLOAT::FRAC-PART 2))
; --> 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 (OR SINGLE-FLOAT DOUBLE-FLOAT (RATIONAL 0 (2))), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR SINGLE-FLOAT DOUBLE-FLOAT (RATIONAL 0 (2))), not a DOUBLE-FLOAT.

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

; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 
; ==>
;   (+ REM SB-C::DIVISOR)
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT), not a RATIONAL.

; --> 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 (OR SINGLE-FLOAT DOUBLE-FLOAT (RATIONAL 0 (2))), not a FLOAT.

;     (FLOOR LISP-BINARY/FLOAT::FRACTION)
; --> 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.

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

;     (ASH 1 LISP-BINARY/FLOAT::N)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (< (ASH 1 LISP-BINARY/FLOAT::N) LISP-BINARY/FLOAT::INT-PART)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.

;     (LOOP LISP-BINARY/FLOAT::FOR LISP-BINARY/FLOAT::N LISP-BINARY/FLOAT::FROM 0
;           UNLESS (< (ASH 1 LISP-BINARY/FLOAT::N)
;                     LISP-BINARY/FLOAT::INT-PART) RETURN LISP-BINARY/FLOAT::N)
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ LISP-BINARY/FLOAT::N 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.

;     (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS LISP-BINARY/FLOAT::BITS-CONSUMED)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a UNSIGNED-BYTE, 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 T, not a (SIGNED-BYTE 64).
;       The second argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (ASH LISP-BINARY/FLOAT::INT-PART
;          (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS LISP-BINARY/FLOAT::BITS-CONSUMED))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (INCF LISP-BINARY/FLOAT::BITS-CONSUMED)
; --> SETQ THE 
; ==>
;   (+ 1 LISP-BINARY/FLOAT::BITS-CONSUMED)
; 
; 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.

;     (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS
;        (INCF LISP-BINARY/FLOAT::BITS-CONSUMED))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The second argument is a (INTEGER 1), not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS LISP-BINARY/FLOAT::BITS-CONSUMED)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The second argument is a (INTEGER 1), not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

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

;     (LOOP LISP-BINARY/FLOAT::FOR BIT LISP-BINARY/FLOAT::DOWNFROM (-
;                                                                   LISP-BINARY/FLOAT::SIGNIFICAND-BITS
;                                                                   (INCF
;                                                                    LISP-BINARY/FLOAT::BITS-CONSUMED))
;           LISP-BINARY/FLOAT::REPEAT (1+
;                                      (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS
;                                         LISP-BINARY/FLOAT::BITS-CONSUMED))
;           LISP-BINARY/FLOAT::SUM (MULTIPLE-VALUE-BIND
;                                      (LISP-BINARY/FLOAT::INT
;                                       LISP-BINARY/FLOAT::FRAC)
;                                      (FLOOR (* LISP-BINARY/FLOAT::FRAC-PART 2))
;                                    (SETF LISP-BINARY/FLOAT::FRAC-PART
;                                            LISP-BINARY/FLOAT::FRAC)
;                                    (ASH LISP-BINARY/FLOAT::INT BIT)))
; --> BLOCK LET LET CEILING CEILING 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.

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

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

; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY IF <= IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (LOGIOR
;      (ASH LISP-BINARY/FLOAT::INT-PART
;           (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS
;              LISP-BINARY/FLOAT::BITS-CONSUMED))
;      (LOOP LISP-BINARY/FLOAT::FOR BIT LISP-BINARY/FLOAT::DOWNFROM (-
;                                                                    LISP-BINARY/FLOAT::SIGNIFICAND-BITS
;                                                                    (INCF
;                                                                     LISP-BINARY/FLOAT::BITS-CONSUMED))
;            LISP-BINARY/FLOAT::REPEAT (1+
;                                       (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS
;                                          LISP-BINARY/FLOAT::BITS-CONSUMED))
;            LISP-BINARY/FLOAT::SUM (MULTIPLE-VALUE-BIND
;                                       (LISP-BINARY/FLOAT::INT
;                                        LISP-BINARY/FLOAT::FRAC)
;                                       (FLOOR (* LISP-BINARY/FLOAT::FRAC-PART 2))
;                                     (SETF LISP-BINARY/FLOAT::FRAC-PART
;                                             LISP-BINARY/FLOAT::FRAC)
;                                     (ASH LISP-BINARY/FLOAT::INT BIT))))
; 
; 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 second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (LOOP LISP-BINARY/FLOAT::FOR BIT LISP-BINARY/FLOAT::DOWNFROM (-
;                                                                   LISP-BINARY/FLOAT::SIGNIFICAND-BITS
;                                                                   (INCF
;                                                                    LISP-BINARY/FLOAT::BITS-CONSUMED))
;           LISP-BINARY/FLOAT::REPEAT (1+
;                                      (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS
;                                         LISP-BINARY/FLOAT::BITS-CONSUMED))
;           LISP-BINARY/FLOAT::SUM (MULTIPLE-VALUE-BIND
;                                      (LISP-BINARY/FLOAT::INT
;                                       LISP-BINARY/FLOAT::FRAC)
;                                      (FLOOR (* LISP-BINARY/FLOAT::FRAC-PART 2))
;                                    (SETF LISP-BINARY/FLOAT::FRAC-PART
;                                            LISP-BINARY/FLOAT::FRAC)
;                                    (ASH LISP-BINARY/FLOAT::INT BIT)))
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY IF DECF SETQ THE 
; --> SB-IMPL::XSUBTRACT BLOCK 
; ==>
;   (- SB-IMPL::B SB-IMPL::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (* LISP-BINARY/FLOAT::FRAC-PART 2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 3) because:
;       The first argument is a (OR (RATIONAL 0 (1)) DOUBLE-FLOAT SINGLE-FLOAT), not a FIXNUM.
;       The result is a (VALUES (OR SINGLE-FLOAT DOUBLE-FLOAT (RATIONAL 0 (2))) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (RATIONAL 0 (1)) DOUBLE-FLOAT SINGLE-FLOAT), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (OR SINGLE-FLOAT DOUBLE-FLOAT (RATIONAL 0 (2))) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (FLOOR (* LISP-BINARY/FLOAT::FRAC-PART 2))
; --> 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 (OR SINGLE-FLOAT DOUBLE-FLOAT (RATIONAL 0 (2))), 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 (OR SINGLE-FLOAT DOUBLE-FLOAT (RATIONAL 0 (2))), 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 (OR SINGLE-FLOAT DOUBLE-FLOAT (RATIONAL 0 (2))), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (OR SINGLE-FLOAT DOUBLE-FLOAT (RATIONAL 0 (2))), 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.

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

;     (ASH LISP-BINARY/FLOAT::INT BIT)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP LISP-BINARY/FLOAT::FOR BIT LISP-BINARY/FLOAT::DOWNFROM (-
;                                                                   LISP-BINARY/FLOAT::SIGNIFICAND-BITS
;                                                                   (INCF
;                                                                    LISP-BINARY/FLOAT::BITS-CONSUMED))
;           LISP-BINARY/FLOAT::REPEAT (1+
;                                      (- LISP-BINARY/FLOAT::SIGNIFICAND-BITS
;                                         LISP-BINARY/FLOAT::BITS-CONSUMED))
;           LISP-BINARY/FLOAT::SUM (MULTIPLE-VALUE-BIND
;                                      (LISP-BINARY/FLOAT::INT
;                                       LISP-BINARY/FLOAT::FRAC)
;                                      (FLOOR (* LISP-BINARY/FLOAT::FRAC-PART 2))
;                                    (SETF LISP-BINARY/FLOAT::FRAC-PART
;                                            LISP-BINARY/FLOAT::FRAC)
;                                    (ASH LISP-BINARY/FLOAT::INT BIT)))
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-2
;      (MULTIPLE-VALUE-BIND (LISP-BINARY/FLOAT::INT LISP-BINARY/FLOAT::FRAC)
;          (FLOOR (* LISP-BINARY/FLOAT::FRAC-PART 2))
;        (SETF LISP-BINARY/FLOAT::FRAC-PART LISP-BINARY/FLOAT::FRAC)
;        (ASH LISP-BINARY/FLOAT::INT BIT)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN ENCODE-FLOAT-BITS/ARITHMETIC
;     (> LISP-BINARY/FLOAT::FRACTION 0.0d0)
; 
; note: unable to open-code RATIONAL to FLOAT comparison due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (> LISP-BINARY/FLOAT::FRACTION 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (- (1- LISP-BINARY/FLOAT::EXPONENT-BIAS))
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (1- LISP-BINARY/FLOAT::EXPONENT-BIAS)))
; 
; note: unable to Eliminate %negate/%negate of rationals due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (EXPT 2 (- (1- LISP-BINARY/FLOAT::EXPONENT-BIAS)))
; 
; note: unable to optimize due to type uncertainty: The second argument is a NUMBER, not a INTEGER.
; 
; note: unable to optimize due to type uncertainty: The second argument is a NUMBER, not a UNSIGNED-BYTE.

;     (/ LISP-BINARY/FLOAT::FRACTION
;        (EXPT 2 (- (1- LISP-BINARY/FLOAT::EXPONENT-BIAS))))
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (> LISP-BINARY/FLOAT::FRACTION 0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       etc.

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

;     (- (1- LISP-BINARY/FLOAT::EXPONENT-BIAS))
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (1- LISP-BINARY/FLOAT::EXPONENT-BIAS)))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       etc.

;     (/ LISP-BINARY/FLOAT::FRACTION
;        (EXPT 2 (- (1- LISP-BINARY/FLOAT::EXPONENT-BIAS))))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) 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).
;       unable to do inline float arithmetic (cost 19) 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).

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

;     (+ (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS) LISP-BINARY/FLOAT::EXPONENT-BITS)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (ASH LISP-BINARY/FLOAT::SIGN
;          (+ (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)
;             LISP-BINARY/FLOAT::EXPONENT-BITS))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

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

;     (ASH 1 (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (1- (ASH 1 (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)))
; ==>
;   (- (ASH 1 (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)) 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.

;     (LOGAND (1- (ASH 1 (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)))
;             LISP-BINARY/FLOAT::SIGNIFICAND)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -1), not a FIXNUM.
;       The second 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 3) because:
;       The first argument is a (INTEGER -1), not a (SIGNED-BYTE 64).
;       The second 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.

;     (LOGIOR
;      (ASH LISP-BINARY/FLOAT::SIGN
;           (+ (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)
;              LISP-BINARY/FLOAT::EXPONENT-BITS))
;      (LOGAND (1- (ASH 1 (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)))
;              LISP-BINARY/FLOAT::SIGNIFICAND)
;      (ASH
;       (IF LISP-BINARY/FLOAT::DENORMALP
;           0
;           (+ LISP-BINARY/FLOAT::EXPONENT LISP-BINARY/FLOAT::EXPONENT-BIAS))
;       (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)))
; --> LOGIOR 
; ==>
;   (LOGIOR
;    (ASH LISP-BINARY/FLOAT::SIGN
;         (+ (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)
;            LISP-BINARY/FLOAT::EXPONENT-BITS))
;    (LOGAND (1- (ASH 1 (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)))
;            LISP-BINARY/FLOAT::SIGNIFICAND))
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       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 (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       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.

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

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

;     (ASH
;      (IF LISP-BINARY/FLOAT::DENORMALP
;          0
;          (+ LISP-BINARY/FLOAT::EXPONENT LISP-BINARY/FLOAT::EXPONENT-BIAS))
;      (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOGIOR
;      (ASH LISP-BINARY/FLOAT::SIGN
;           (+ (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)
;              LISP-BINARY/FLOAT::EXPONENT-BITS))
;      (LOGAND (1- (ASH 1 (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)))
;              LISP-BINARY/FLOAT::SIGNIFICAND)
;      (ASH
;       (IF LISP-BINARY/FLOAT::DENORMALP
;           0
;           (+ LISP-BINARY/FLOAT::EXPONENT LISP-BINARY/FLOAT::EXPONENT-BIAS))
;       (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)))
; ==>
;   (LOGIOR
;    (LOGIOR
;     (ASH LISP-BINARY/FLOAT::SIGN
;          (+ (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)
;             LISP-BINARY/FLOAT::EXPONENT-BITS))
;     (LOGAND (1- (ASH 1 #)) LISP-BINARY/FLOAT::SIGNIFICAND))
;    (ASH
;     (IF LISP-BINARY/FLOAT::DENORMALP
;         0
;         (+ LISP-BINARY/FLOAT::EXPONENT LISP-BINARY/FLOAT::EXPONENT-BIAS))
;     (1- LISP-BINARY/FLOAT::SIGNIFICAND-BITS)))
; 
; 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 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 (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       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.

;     (> LISP-BINARY/FLOAT::FRACTION 0.0d0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a DOUBLE-FLOAT.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN ENCODE-FLOAT-BITS/CFFI
;     (CFFI:WITH-FOREIGN-OBJECT (LISP-BINARY/FLOAT::X
;                                LISP-BINARY/FLOAT::C-FLOAT-TYPE)
;       (SETF (CFFI:MEM-REF LISP-BINARY/FLOAT::X LISP-BINARY/FLOAT::C-FLOAT-TYPE)
;               (COERCE LISP-BINARY/FLOAT::FRACTION LISP-BINARY/FLOAT::LISP-TYPE))
;       (CFFI:MEM-REF LISP-BINARY/FLOAT::X LISP-BINARY/FLOAT::C-INT-TYPE))
; --> CFFI-SYS:WITH-FOREIGN-POINTER LET* 
; ==>
;   (* 1 (CFFI:FOREIGN-TYPE-SIZE LISP-BINARY/FLOAT::C-FLOAT-TYPE))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to associate */(* /) of constants due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to fold identity operations due to type uncertainty: The first argument is a NUMBER, not a (OR RATIONAL (COMPLEX RATIONAL)).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 3) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first 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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN ENCODE-FLOAT-BITS/RUNTIME-FORMAT
;     (COERCE LISP-BINARY/FLOAT::FRACTION 'FLOAT)
; --> THE 
; ==>
;   (SB-KERNEL:%SINGLE-FLOAT SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/float.lisp
; in: DEFUN DECODE-FLOAT-BITS/CFFI
;     (CFFI:WITH-FOREIGN-OBJECT (LISP-BINARY/FLOAT::X LISP-BINARY/FLOAT::C-INT-TYPE)
;       (SETF (CFFI:MEM-REF LISP-BINARY/FLOAT::X LISP-BINARY/FLOAT::C-INT-TYPE)
;               INTEGER)
;       (CFFI:MEM-REF LISP-BINARY/FLOAT::X LISP-BINARY/FLOAT::C-FLOAT-TYPE))
; --> CFFI-SYS:WITH-FOREIGN-POINTER LET* 
; ==>
;   (* 1 (CFFI:FOREIGN-TYPE-SIZE LISP-BINARY/FLOAT::C-INT-TYPE))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to associate */(* /) of constants due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to fold identity operations due to type uncertainty: The first argument is a NUMBER, not a (OR RATIONAL (COMPLEX RATIONAL)).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 3) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first 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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/reverse-stream.lisp
; in: DEFMETHOD STREAM-READ-BYTE (REVERSE-STREAM)
;     (DEFMETHOD STREAM-READ-BYTE ((STREAM REVERSE-STREAM:REVERSE-STREAM))
;       (REVERSE-STREAM::REVERSE-BYTE
;        (READ-BYTE (SLOT-VALUE STREAM 'REVERSE-STREAM::REAL-STREAM))
;        (SLOT-VALUE STREAM 'REVERSE-STREAM::LOOKUP-TABLE)))
; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; ==>
;   (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'STREAM-READ-BYTE 'NIL
;                           (LIST (FIND-CLASS 'REVERSE-STREAM:REVERSE-STREAM))
;                           '(STREAM)
;                           (LIST* :FUNCTION
;                                  (LET* ((SB-PCL::FMF #) (SB-PCL::MF #))
;                                    (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
;                                     SB-PCL::MF
;                                     (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
;                                      SB-PCL::FMF '#))
;                                    SB-PCL::MF)
;                                  '(SB-PCL::SIMPLE-NEXT-METHOD-CALL T
;                                    SB-PCL::PLIST
;                                    (:ARG-INFO (1) :SLOT-NAME-LISTS (#))))
;                           (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Call to REVERSE-STREAM::REVERSE-BYTE could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "lisp-binary" "reverse-stream">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/binary.lisp
; in: DEFUN TYPE-SIZE
;     'LISP-BINARY::UNKNOWN-TYPE-SIZE
; 
; note: deleting unreachable code

;     (VALUES 8 T :NORMAL-STREAM)
; 
; note: deleting unreachable code

;     (VALUES 8 NIL :BIT-STREAM-THIS-FIELD)
; 
; note: deleting unreachable code

;     (VALUES 1 NIL :BIT-STREAM-ONLY)
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lisp-binary/4a7833a97182fdff51c5dd2205cbfefa07509701/lisp-binary-20180131-git/binary.lisp
; in: DEFUN EXPAND-DEFBINARY-TYPE-FIELD
;     (QUASIQUOTE-2.0:DIG
;      (LET (((QUASIQUOTE-2.0:INJECT LISP-BINARY:BUFFER)
;             (MAKE-ARRAY # :ELEMENT-TYPE '#))
;            ((QUA