incless

incless-extension-extrinsic

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/quaviver/f0809a491744fb53eeb3651b610a8cf9f1fa7006/quaviver-20260327-git/code/math/count-digits.lisp
; in: DEFUN COUNT-DIGITS
;     (LENGTH QUAVIVER.MATH::TABLE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (< COUNT (LENGTH QUAVIVER.MATH::TABLE))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.

;     (EXPT QUAVIVER.MATH::BASE COUNT)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR (FLOAT 0.0) (RATIONAL 0)), not a INTEGER.

;     (INTEGER-LENGTH QUAVIVER.MATH::VALUE)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (< COUNT (LENGTH QUAVIVER.MATH::TABLE))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.

;     (< QUAVIVER.MATH::VALUE
;        (LET ((QUAVIVER.MATH::TABLE (SVREF QUAVIVER.MATH::*COUNT-DIGITS-TABLE* #)))
;          (IF (< COUNT (LENGTH QUAVIVER.MATH::TABLE))
;              (SVREF QUAVIVER.MATH::TABLE COUNT)
;              (EXPT QUAVIVER.MATH::BASE COUNT))))
; 
; 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 T, not a FIXNUM.

;     (DEFUN QUAVIVER.MATH:COUNT-DIGITS (QUAVIVER.MATH::BASE QUAVIVER.MATH::VALUE)
;       (DECLARE (OPTIMIZE SPEED))
;       (LET ((QUAVIVER.MATH::LEN (INTEGER-LENGTH QUAVIVER.MATH::VALUE)))
;         (COND ((ZEROP QUAVIVER.MATH::LEN) 1)
;               ((EQL QUAVIVER.MATH::BASE 2) QUAVIVER.MATH::LEN)
;               ((= # 1) (VALUES #)) (T (MULTIPLE-VALUE-BIND # # #)))))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/quaviver/f0809a491744fb53eeb3651b610a8cf9f1fa7006/quaviver-20260327-git/code/primitive-triple-bits.lisp
; in: DEFMETHOD PRIMITIVE-TRIPLE-BITS ((EQL :BFLOAT16) T T T)
;     (QUAVIVER::%PRIMITIVE-TRIPLE-BITS :BFLOAT16 QUAVIVER::SIGNIFICAND
;                                       QUAVIVER::EXPONENT QUAVIVER::SIGN)
; --> COND IF PROGN ECASE COND IF IF IF SETF SB-C::WITH-SOURCE-FORM LDB LET* IF 
; --> ZEROP 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; --> COND IF OR LET ZEROP 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; --> COND IF OR LET IF IF IF THE LET* - 
; ==>
;   (INTEGER-LENGTH QUAVIVER::SIGNIFICAND)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

; --> COND IF OR LET IF IF IF THE LET* 
; ==>
;   (ASH QUAVIVER::SIGNIFICAND QUAVIVER::SHIFT)
; 
; 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 -274877906935 8), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -274877906935 8), not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; --> COND IF PROGN ECASE COND IF IF SETF PROGN SETF SB-C::WITH-SOURCE-FORM LDB 
; --> LET* SETQ THE DPB 
; ==>
;   1
; 
; note: forced to do LOGAND-WORD-MASK (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       etc.

; --> COND IF PROGN ECASE COND IF IF IF SETF SB-C::WITH-SOURCE-FORM LDB LET* 
; --> SETQ THE DPB 
; ==>
;   1
; 
; note: forced to do LOGAND-WORD-MASK (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

; in: DEFMETHOD PRIMITIVE-TRIPLE-BITS ((EQL :BINARY16) T T T)
;     (QUAVIVER::%PRIMITIVE-TRIPLE-BITS :BINARY16 QUAVIVER::SIGNIFICAND
;                                       QUAVIVER::EXPONENT QUAVIVER::SIGN)
; --> COND IF PROGN ECASE COND IF IF IF SETF SB-C::WITH-SOURCE-FORM LDB LET* IF 
; --> ZEROP 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; --> COND IF OR LET ZEROP 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; --> COND IF OR LET IF IF IF THE LET* - 
; ==>
;   (INTEGER-LENGTH QUAVIVER::SIGNIFICAND)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

; --> COND IF OR LET IF IF IF THE LET* 
; ==>
;   (ASH QUAVIVER::SIGNIFICAND QUAVIVER::SHIFT)
; 
; 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 -274877906932 11), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -274877906932 11), not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; --> COND IF PROGN ECASE COND IF IF SETF PROGN SETF SB-C::WITH-SOURCE-FORM LDB 
; --> LET* SETQ THE DPB 
; ==>
;   1
; 
; note: forced to do LOGAND-WORD-MASK (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       etc.

; --> COND IF PROGN ECASE COND IF IF IF SETF SB-C::WITH-SOURCE-FORM LDB LET* 
; --> SETQ THE DPB 
; ==>
;   1
; 
; note: forced to do LOGAND-WORD-MASK (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

; in: DEFMETHOD PRIMITIVE-TRIPLE-BITS ((EQL :BINARY32) T T T)
;     (QUAVIVER::%PRIMITIVE-TRIPLE-BITS :BINARY32 QUAVIVER::SIGNIFICAND
;                                       QUAVIVER::EXPONENT QUAVIVER::SIGN)
; --> COND IF PROGN ECASE COND IF IF IF SETF SB-C::WITH-SOURCE-FORM LDB LET* IF 
; --> ZEROP 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; --> COND IF OR LET ZEROP 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; --> COND IF OR LET IF IF IF THE LET* - 
; ==>
;   (INTEGER-LENGTH QUAVIVER::SIGNIFICAND)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

; --> COND IF OR LET IF IF IF THE LET* 
; ==>
;   (ASH QUAVIVER::SIGNIFICAND QUAVIVER::SHIFT)
; 
; 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 -274877906919 24), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -274877906919 24), not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; --> COND IF PROGN ECASE COND IF IF SETF PROGN SETF SB-C::WITH-SOURCE-FORM LDB 
; --> LET* SETQ THE DPB 
; ==>
;   1
; 
; note: forced to do LOGAND-WORD-MASK (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       etc.

; --> COND IF PROGN ECASE COND IF IF IF SETF SB-C::WITH-SOURCE-FORM LDB LET* 
; --> SETQ THE DPB 
; ==>
;   1
; 
; note: forced to do LOGAND-WORD-MASK (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

; in: DEFMETHOD PRIMITIVE-TRIPLE-BITS ((EQL :BINARY64) T T T)
;     (QUAVIVER::%PRIMITIVE-TRIPLE-BITS :BINARY64 QUAVIVER::SIGNIFICAND
;                                       QUAVIVER::EXPONENT QUAVIVER::SIGN)
; --> COND IF PROGN ECASE COND IF IF IF SETF SB-C::WITH-SOURCE-FORM LDB LET* IF 
; --> ZEROP 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; --> COND IF OR LET ZEROP 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; --> COND IF OR LET IF IF IF THE LET* - 
; ==>
;   (INTEGER-LENGTH QUAVIVER::SIGNIFICAND)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

; --> COND IF OR LET IF IF IF THE LET* 
; ==>
;   (ASH QUAVIVER::SIGNIFICAND QUAVIVER::SHIFT)
; 
; 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 -274877906890 53), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -274877906890 53), not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; --> COND IF PROGN ECASE COND IF IF SETF PROGN SETF SB-C::WITH-SOURCE-FORM LDB 
; --> LET* SETQ THE DPB 
; ==>
;   1
; 
; note: forced to do LOGAND-WORD-MASK (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       etc.

; --> COND IF PROGN ECASE COND IF IF IF SETF SB-C::WITH-SOURCE-FORM LDB LET* 
; --> SETQ THE DPB 
; ==>
;   1
; 
; note: forced to do LOGAND-WORD-MASK (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

; in: DEFMETHOD PRIMITIVE-TRIPLE-BITS ((EQL :BINARY80) T T T)
;     (QUAVIVER::%PRIMITIVE-TRIPLE-BITS :BINARY80 QUAVIVER::SIGNIFICAND
;                                       QUAVIVER::EXPONENT QUAVIVER::SIGN)
; --> COND IF PROGN ECASE COND IF IF IF SETF SB-C::WITH-SOURCE-FORM LDB LET* IF 
; --> ZEROP 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; --> COND IF OR LET ZEROP 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; --> COND IF OR LET IF IF IF THE LET* COND IF IF THE PROGN COND IF SETF PROGN 
; --> SETF SB-C::WITH-SOURCE-FORM LDB LET* SETQ THE DPB 
; ==>
;   1
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (OR (UNSIGNED-BYTE 64) (INTEGER 604462909807314587353088 604481356551388296904703)) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (OR (UNSIGNED-BYTE 64) (INTEGER 604462909807314587353088 604481356551388296904703)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

; --> COND IF OR LET IF IF IF THE LET* COND IF IF THE PROGN COND IF THE SETF 
; --> SB-C::WITH-SOURCE-FORM LDB LET* SETQ THE DPB 
; ==>
;   1
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (OR (UNSIGNED-BYTE 64) (INTEGER 604462909807314587353088 604481356551388296904703)) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (OR (UNSIGNED-BYTE 64) (INTEGER 604462909807314587353088 604481356551388296904703)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

; --> COND IF OR LET IF IF IF THE LET* - 
; ==>
;   (INTEGER-LENGTH QUAVIVER::SIGNIFICAND)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

; --> COND IF OR LET IF IF IF THE LET* 
; ==>
;   (ASH QUAVIVER::SIGNIFICAND QUAVIVER::SHIFT)
; 
; 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 -274877906879 64), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -274877906879 64), not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; --> COND IF OR LET IF IF IF THE LET* COND IF IF THE PROGN COND IF THE SETF 
; --> SB-C::WITH-SOURCE-FORM LDB LET* SETQ THE DPB 
; ==>
;   1
; 
; note: doing unsigned word to integer coercion (cost 20)

; in: DEFMETHOD PRIMITIVE-TRIPLE-BITS ((EQL :BINARY128) T T T)
;     (QUAVIVER::%PRIMITIVE-TRIPLE-BITS :BINARY128 QUAVIVER::SIGNIFICAND
;                                       QUAVIVER::EXPONENT QUAVIVER::SIGN)
; --> COND IF PROGN ECASE COND IF IF IF SETF SB-C::WITH-SOURCE-FORM LDB LET* IF 
; --> ZEROP 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; --> COND IF OR LET ZEROP 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; --> COND IF OR LET IF IF IF THE LET* COND IF IF THE PROGN COND IF SETF PROGN 
; --> SETF SB-C::WITH-SOURCE-FORM LDB LET* SETQ THE DPB 
; ==>
;   1
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (OR (UNSIGNED-BYTE 112) (INTEGER 170141183460469231731687303715884105728 170146375757327766559315834212213325823)) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (OR (UNSIGNED-BYTE 112) (INTEGER 170141183460469231731687303715884105728 170146375757327766559315834212213325823)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

; --> COND IF OR LET IF IF IF THE LET* COND IF IF THE PROGN COND IF THE SETF 
; --> SB-C::WITH-SOURCE-FORM LDB LET* LDB 
; ==>
;   1
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (UNSIGNED-BYTE 112) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).

; --> COND IF OR LET IF IF IF THE LET* COND IF IF THE PROGN COND IF THE SETF 
; --> SB-C::WITH-SOURCE-FORM LDB LET* SETQ THE DPB 
; ==>
;   1
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (OR (UNSIGNED-BYTE 112) (INTEGER 170141183460469231731687303715884105728 170146375757327766559315834212213325823)) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (OR (UNSIGNED-BYTE 112) (INTEGER 170141183460469231731687303715884105728 170146375757327766559315834212213325823)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

; --> COND IF OR LET IF IF IF THE LET* - 
; ==>
;   (INTEGER-LENGTH QUAVIVER::SIGNIFICAND)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

; --> COND IF OR LET IF IF IF THE LET* 
; ==>
;   (ASH QUAVIVER::SIGNIFICAND QUAVIVER::SHIFT)
; 
; 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 -274877906830 113), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -274877906830 113), not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD PRIMITIVE-TRIPLE-BITS ((EQL :BINARY256) T T T)
;     (QUAVIVER::%PRIMITIVE-TRIPLE-BITS :BINARY256 QUAVIVER::SIGNIFICAND
;                                       QUAVIVER::EXPONENT QUAVIVER::SIGN)
; --> COND IF PROGN ECASE COND IF IF IF SETF SB-C::WITH-SOURCE-FORM LDB LET* IF 
; --> ZEROP 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; --> COND IF OR LET ZEROP 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; --> COND IF OR LET IF IF IF THE LET* COND IF IF THE PROGN COND IF SETF PROGN 
; --> SETF SB-C::WITH-SOURCE-FORM LDB LET* SETQ THE DPB 
; ==>
;   1
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (OR (UNSIGNED-BYTE 236) (INTEGER 57896044618658097711785492504343953926634992332820282019728792003956564819968 57896155046599646360806091460437750359042231550563836745913674604344145608703)) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (OR (UNSIGNED-BYTE 236) (INTEGER 57896044618658097711785492504343953926634992332820282019728792003956564819968 57896155046599646360806091460437750359042231550563836745913674604344145608703)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

; --> COND IF OR LET IF IF IF THE LET* COND IF IF THE PROGN COND IF THE SETF 
; --> SB-C::WITH-SOURCE-FORM LDB LET* LDB 
; ==>
;   1
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (UNSIGNED-BYTE 236) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).

; --> COND IF OR LET IF IF IF THE LET* COND IF IF THE PROGN COND IF THE SETF 
; --> SB-C::WITH-SOURCE-FORM LDB LET* SETQ THE DPB 
; ==>
;   1
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (OR (UNSIGNED-BYTE 236) (INTEGER 57896044618658097711785492504343953926634992332820282019728792003956564819968 57896155046599646360806091460437750359042231550563836745913674604344145608703)) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (OR (UNSIGNED-BYTE 236) (INTEGER 57896044618658097711785492504343953926634992332820282019728792003956564819968 57896155046599646360806091460437750359042231550563836745913674604344145608703)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

; --> COND IF OR LET IF IF IF THE LET* - 
; ==>
;   (INTEGER-LENGTH QUAVIVER::SIGNIFICAND)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

; --> COND IF OR LET IF IF IF THE LET* 
; ==>
;   (ASH QUAVIVER::SIGNIFICAND QUAVIVER::SHIFT)
; 
; 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 -274877906706 237), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -274877906706 237), not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/quaviver/f0809a491744fb53eeb3651b610a8cf9f1fa7006/quaviver-20260327-git/code/float-bits-late.lisp
; in: DEFMETHOD FLOAT-BITS ((EQL :BINARY80) T)
;     (QUAVIVER::%FLOAT-EXTERNAL :BINARY80 QUAVIVER::VALUE)
; --> MULTIPLE-VALUE-CALL FUNCTION LET COND IF OR LET IF IF IF THE LET* COND IF 
; --> IF THE PROGN COND IF SETF PROGN SETF SB-C::WITH-SOURCE-FORM LDB LET* SETQ 
; --> THE DPB 
; ==>
;   1
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (OR (UNSIGNED-BYTE 64) (INTEGER 604462909807314587353088 604481356551388296904703)) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (OR (UNSIGNED-BYTE 64) (INTEGER 604462909807314587353088 604481356551388296904703)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

; --> MULTIPLE-VALUE-CALL FUNCTION LET COND IF OR LET IF IF IF THE LET* 
; ==>
;   (ASH QUAVIVER::SIGNIFICAND QUAVIVER::SHIFT)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The result is a (VALUES (INTEGER 32 5316911983139663482391856204266602496) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 4) because:
;       The result is a (VALUES (INTEGER 32 5316911983139663482391856204266602496) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD FLOAT-BITS ((EQL :BINARY128) T)
;     (QUAVIVER::%FLOAT-EXTERNAL :BINARY128 QUAVIVER::VALUE)
; --> MULTIPLE-VALUE-CALL FUNCTION LET COND IF OR LET IF IF IF THE LET* COND IF 
; --> IF THE PROGN COND IF SETF PROGN SETF SB-C::WITH-SOURCE-FORM LDB LET* SETQ 
; --> THE DPB 
; ==>
;   1
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (OR (UNSIGNED-BYTE 112) (INTEGER 170141183460469231731687303715884105728 170146375757327766559315834212213325823)) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (OR (UNSIGNED-BYTE 112) (INTEGER 170141183460469231731687303715884105728 170146375757327766559315834212213325823)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

; --> MULTIPLE-VALUE-CALL FUNCTION LET COND IF OR LET IF IF IF THE LET* 
; ==>
;   (ASH QUAVIVER::SIGNIFICAND QUAVIVER::SHIFT)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The result is a (VALUES (INTEGER 18014398509481984 2993155353253689171288849678868119995724853518794752) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 4) because:
;       The result is a (VALUES (INTEGER 18014398509481984 2993155353253689171288849678868119995724853518794752) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD FLOAT-BITS ((EQL :BINARY256) T)
;     (QUAVIVER::%FLOAT-EXTERNAL :BINARY256 QUAVIVER::VALUE)
; --> MULTIPLE-VALUE-CALL FUNCTION LET COND IF OR LET IF IF IF THE LET* COND IF 
; --> IF THE PROGN COND IF SETF PROGN SETF SB-C::WITH-SOURCE-FORM LDB LET* SETQ 
; --> THE DPB 
; ==>
;   1
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (OR (UNSIGNED-BYTE 236) (INTEGER 57896044618658097711785492504343953926634992332820282019728792003956564819968 57896155046599646360806091460437750359042231550563836745913674604344145608703)) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
; 
; note: unable to convert to inline logical operations due to type uncertainty: The result is a (VALUES (OR (UNSIGNED-BYTE 236) (INTEGER 57896044618658097711785492504343953926634992332820282019728792003956564819968 57896155046599646360806091460437750359042231550563836745913674604344145608703)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/quaviver/f0809a491744fb53eeb3651b610a8cf9f1fa7006/quaviver-20260327-git/code/compose-digits.lisp
; in: DEFUN %COMPOSE-DIGITS/VECTOR
;     (ZEROP QUAVIVER::VALUE)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

;     (QUAVIVER.MATH:COUNT-DIGITS QUAVIVER::BASE QUAVIVER::VALUE)
; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF < LET IF < 
; ==>
;   (LENGTH QUAVIVER.MATH::TABLE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF < LET IF 
; ==>
;   (< COUNT (LENGTH QUAVIVER.MATH::TABLE))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.

; ==>
;   (EXPT QUAVIVER.MATH::BASE COUNT)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR (FLOAT 0.0) (RATIONAL 0)), not a INTEGER.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> BLOCK LET 
; ==>
;   (INTEGER-LENGTH QUAVIVER.MATH::VALUE)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       etc.

; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF < LET IF 
; ==>
;   (< COUNT (LENGTH QUAVIVER.MATH::TABLE))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.

; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF 
; ==>
;   (< QUAVIVER.MATH::VALUE
;      (LET ((QUAVIVER.MATH::TABLE (SVREF QUAVIVER.MATH::*COUNT-DIGITS-TABLE* #)))
;        (IF (< COUNT (LENGTH QUAVIVER.MATH::TABLE))
;            (SVREF QUAVIVER.MATH::TABLE COUNT)
;            (EXPT QUAVIVER.MATH::BASE COUNT))))
; 
; 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 T, not a FIXNUM.

; in: DEFUN %COMPOSE-DIGITS/BASE-STRING
;     (ZEROP QUAVIVER::VALUE)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

;     (QUAVIVER.MATH:COUNT-DIGITS QUAVIVER::BASE QUAVIVER::VALUE)
; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF < LET IF < 
; ==>
;   (LENGTH QUAVIVER.MATH::TABLE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF < LET IF 
; ==>
;   (< COUNT (LENGTH QUAVIVER.MATH::TABLE))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.

; ==>
;   (EXPT QUAVIVER.MATH::BASE COUNT)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR (FLOAT 0.0) (RATIONAL 0)), not a INTEGER.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> BLOCK LET 
; ==>
;   (INTEGER-LENGTH QUAVIVER.MATH::VALUE)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       etc.

; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF < LET IF 
; ==>
;   (< COUNT (LENGTH QUAVIVER.MATH::TABLE))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.

; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF 
; ==>
;   (< QUAVIVER.MATH::VALUE
;      (LET ((QUAVIVER.MATH::TABLE (SVREF QUAVIVER.MATH::*COUNT-DIGITS-TABLE* #)))
;        (IF (< COUNT (LENGTH QUAVIVER.MATH::TABLE))
;            (SVREF QUAVIVER.MATH::TABLE COUNT)
;            (EXPT QUAVIVER.MATH::BASE COUNT))))
; 
; 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 T, not a FIXNUM.

; in: DEFUN %COMPOSE-DIGITS/STRING
;     (ZEROP QUAVIVER::VALUE)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

;     (QUAVIVER.MATH:COUNT-DIGITS QUAVIVER::BASE QUAVIVER::VALUE)
; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF < LET IF < 
; ==>
;   (LENGTH QUAVIVER.MATH::TABLE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF < LET IF 
; ==>
;   (< COUNT (LENGTH QUAVIVER.MATH::TABLE))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.

; ==>
;   (EXPT QUAVIVER.MATH::BASE COUNT)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR (FLOAT 0.0) (RATIONAL 0)), not a INTEGER.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> BLOCK LET 
; ==>
;   (INTEGER-LENGTH QUAVIVER.MATH::VALUE)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       etc.

; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF < LET IF 
; ==>
;   (< COUNT (LENGTH QUAVIVER.MATH::TABLE))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.

; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF 
; ==>
;   (< QUAVIVER.MATH::VALUE
;      (LET ((QUAVIVER.MATH::TABLE (SVREF QUAVIVER.MATH::*COUNT-DIGITS-TABLE* #)))
;        (IF (< COUNT (LENGTH QUAVIVER.MATH::TABLE))
;            (SVREF QUAVIVER.MATH::TABLE COUNT)
;            (EXPT QUAVIVER.MATH::BASE COUNT))))
; 
; 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 T, not a FIXNUM.

; in: DEFUN %COMPOSE-DIGITS/LIST
;     (ZEROP QUAVIVER::VALUE)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

;     (FLOOR QUAVIVER::VALUE QUAVIVER::BASE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a INTEGER.The second argument is a REAL, not a INTEGER.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a INTEGER.The second argument is a REAL, not a FIXNUM.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/quaviver/f0809a491744fb53eeb3651b610a8cf9f1fa7006/quaviver-20260327-git/code/write-digits.lisp
; in: DEFUN %WRITE-SMALLNUM-DIGITS
;     (QUAVIVER.MATH:COUNT-DIGITS QUAVIVER::BASE QUAVIVER::VALUE)
; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF < LET IF < 
; ==>
;   (LENGTH QUAVIVER.MATH::TABLE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF < LET IF 
; ==>
;   (< COUNT (LENGTH QUAVIVER.MATH::TABLE))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.

; ==>
;   (EXPT QUAVIVER.MATH::BASE COUNT)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR (FLOAT 0.0) (RATIONAL 0)), not a INTEGER.

; --> BLOCK LET 
; ==>
;   (INTEGER-LENGTH QUAVIVER.MATH::VALUE)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF < LET IF 
; ==>
;   (< COUNT (LENGTH QUAVIVER.MATH::TABLE))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.

; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF 
; ==>
;   (< QUAVIVER.MATH::VALUE
;      (LET ((QUAVIVER.MATH::TABLE (SVREF QUAVIVER.MATH::*COUNT-DIGITS-TABLE* #)))
;        (IF (< COUNT (LENGTH QUAVIVER.MATH::TABLE))
;            (SVREF QUAVIVER.MATH::TABLE COUNT)
;            (EXPT QUAVIVER.MATH::BASE COUNT))))
; 
; 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 T, not a FIXNUM.

; in: DEFUN %WRITE-BIGNUM-DIGITS
;     (QUAVIVER.MATH:COUNT-DIGITS QUAVIVER::BASE QUAVIVER::VALUE)
; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF < LET IF < 
; ==>
;   (LENGTH QUAVIVER.MATH::TABLE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF < LET IF 
; ==>
;   (< COUNT (LENGTH QUAVIVER.MATH::TABLE))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.

; ==>
;   (EXPT QUAVIVER.MATH::BASE COUNT)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR (FLOAT 0.0) (RATIONAL 0)), not a INTEGER.

; --> BLOCK LET 
; ==>
;   (INTEGER-LENGTH QUAVIVER.MATH::VALUE)
; 
; note: forced to do full call
;       unable to do inline (unsigned-byte 64) integer-length (cost 26) because:
;       The first argument is a (INTEGER 4611686018427387904), not a (UNSIGNED-BYTE 64).

; --> BLOCK LET COND IF IF IF THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION IF OR LET IF < LET IF 
; ==>
;   (< COUNT (LENGTH QUAVIVER.MATH::TABLE))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/incless/18a689bd615aabed86d878707d3087f7259667e3/incless-20260327-git/code/float.lisp
; in: DEFUN WRITE-EXPONENT-MARKER
;     (SINGLE-FLOAT #\f)
; 
; caught STYLE-WARNING:
;   Clause SINGLE-FLOAT is shadowed by SHORT-FLOAT

; in: DEFUN PRINT-FLOAT
;     (QUAVIVER.MATH:COUNT-DIGITS 10 INCLESS::SIGNIFICAND)
; ==>
;   (INTEGER-LENGTH QUAVIVER.MATH::VALUE)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "incless" "code" "float">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/quaviver/f0809a491744fb53eeb3651b610a8cf9f1fa7006/quaviver-20260327-git/code/trailing-zeros/implementation.lisp
; in: DEFUN ROTR/64
;     (DEFUN QUAVIVER/TRAILING-ZEROS::ROTR/64 (COUNT INTEGER)
;       (DECLARE (OPTIMIZE SPEED)
;                ((INTEGER 0 (64)) COUNT)
;                ((UNSIGNED-BYTE 64) INTEGER))
;       (SB-ROTATE-BYTE:ROTATE-BYTE (- COUNT) (BYTE 64 0) INTEGER))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA QUAVIVER/TRAILING-ZEROS::ROTR/64
;         (COUNT INTEGER)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (OPTIMIZE SPEED)
;                ((INTEGER 0 (64)) COUNT)
;                ((UNSIGNED-BYTE 64) INTEGER))
;       (BLOCK QUAVIVER/TRAILING-ZEROS::ROTR/64
;         (SB-ROTATE-BYTE:ROTATE-BYTE (- COUNT) (BYTE 64 0) INTEGER)))
; 
; note: doing unsigned word to integer coercion (cost 20) to "<return value>"

; in: DEFUN REMOVE-TRAILING-ZEROS/64
;     (IF QUAVIVER/TRAILING-ZEROS::B
;         QUAVIVER/TRAILING-ZEROS::R
;         QUAVIVER/TRAILING-ZEROS::SIGNIFICAND)
; 
; note: doing unsigned word to integer coercion (cost 20) from R
; 
; note: doing unsigned word to integer coercion (cost 20) from R
; 
; note: doing unsigned word to integer coercion (cost 20) from R
; 
; note: doing unsigned word to integer coercion (cost 20) from R
; 
; caught ERROR:
;   READ error during COMPILE-FILE: Package INCLESS-EXTENSION does not exist. Line: 3, Column: 42, File-Position: 85 Stream: #<SB-INT:FORM-TRACKING-STREAM for "file /home/quicklisp/quicklisp-controller/dist/build-cache/incless/18a689bd615aabed86d878707d3087f7259667e3/incless-20260327-git/code/extension-extrinsic/interface.lisp" {121B480003}>
Unhandled UIOP/LISP-BUILD:COMPILE-FILE-ERROR in thread #<SB-THREAD:THREAD tid=724779 "main thread" RUNNING {1200030003}>: COMPILE-FILE-ERROR while compiling #<CL-SOURCE-FILE "incless-extension-extrinsic" "code" "interface">

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

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

incless-extension-intrinsic

incless-extension-extrinsic
