data-frame

SBCL 2.5.7.135-b5e53e27e / ASDF 3.3.5

data-frame/tests

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/special-functions/31c0dd2f65c270feb13d8c2ad9c29dc9f81ea776/special-functions-20250828-git/src/log-gamma.lisp
; in: DEFUN LOG-GAMMA
;     (LOG
;      (/ PI
;         (ABS
;          (* (SPECIAL-FUNCTIONS::SIN-PI SPECIAL-FUNCTIONS::N)
;             SPECIAL-FUNCTIONS::N))))
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/distributions/39bb98bb9237cc4d83ee4d811ee885dcb066a237/distributions-20250828-git/src/bernoulli.lisp
; in: DECLAIM (INLINE DRAW-BERNOULLI DRAW-BERNOULLI-BIT)
;     (DECLAIM
;      (INLINE DISTRIBUTIONS:DRAW-BERNOULLI DISTRIBUTIONS::DRAW-BERNOULLI-BIT))
; ==>
;   (SB-C::%PROCLAIM
;    '(INLINE DISTRIBUTIONS:DRAW-BERNOULLI DISTRIBUTIONS::DRAW-BERNOULLI-BIT)
;    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming DISTRIBUTIONS:DRAW-BERNOULLI to be INLINE, but 1 call to it was previously compiled. A declaration of NOTINLINE at the call site will eliminate this warning, as will proclaiming and defining the function before its first potential use.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "distributions" "bernoulli">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/statistics/dd4153c8e73ae8b85ed2082b488eb18214ff0bd9/statistics-20250828-git/lh-statistics.lisp
; in: DEFUN MEAN
;     (LENGTH SEQUENCE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS VECTOR SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

;     (/ (REDUCE #'+ SEQUENCE) (LENGTH SEQUENCE))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (LH.STATISTICS:TEST-VARIABLES (SEQUENCE :NUMSEQ))
; --> THE UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFUN MEDIAN
;     (LH.STATISTICS:TEST-VARIABLES (SEQUENCE :NUMSEQ))
; --> THE UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFUN MODE
;     (> LH.STATISTICS::VALUE LH.STATISTICS::MODE-COUNT)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.

;     (= LH.STATISTICS::VALUE LH.STATISTICS::MODE-COUNT)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

;     (LH.STATISTICS:TEST-VARIABLES (SEQUENCE :NUMSEQ))
; --> THE UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

;     (INCF (GETHASH ELT LH.STATISTICS::COUNT-TABLE 0))
; ==>
;   (+ 1 (GETHASH #:KEY #:HASHTABLE 0))
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (> LH.STATISTICS::VALUE LH.STATISTICS::MODE-COUNT)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, 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 T, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (= LH.STATISTICS::VALUE LH.STATISTICS::MODE-COUNT)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.

; in: DEFUN GEOMETRIC-MEAN
;     (LOG LH.STATISTICS::X LH.STATISTICS::BASE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The second argument is a REAL, not a SINGLE-FLOAT.The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The second argument is a REAL, not a DOUBLE-FLOAT.The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.The second argument is a REAL, not a SINGLE-FLOAT.The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.The second argument is a REAL, not a DOUBLE-FLOAT.The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (LH.STATISTICS:TEST-VARIABLES (SEQUENCE :NONZERO-NUMSEQ)
;                                   (LH.STATISTICS::BASE :POSNUM))
; --> LET UNLESS IF AND IF EVERY 
; ==>
;   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.

; --> LET IF UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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 LH.STATISTICS::BASE
;           (LH.STATISTICS:MEAN
;            (MAP 'LIST
;                 #'(LAMBDA (LH.STATISTICS::X)
;                     (LOG LH.STATISTICS::X LH.STATISTICS::BASE))
;                 SEQUENCE)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL (0)), 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).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL (0)), 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).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL (0)), not a SINGLE-FLOAT.The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL (0)), not a DOUBLE-FLOAT.The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL (0)), not a (OR RATIONAL (COMPLEX RATIONAL)).The second argument is a NUMBER, not a INTEGER.

;     (LH.STATISTICS:TEST-VARIABLES (SEQUENCE :NONZERO-NUMSEQ)
;                                   (LH.STATISTICS::BASE :POSNUM))
; --> LET UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

; --> LET IF UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

; in: DEFUN SAMPLE-RANGE
;     (LH.STATISTICS:TEST-VARIABLES (SEQUENCE :NUMSEQ))
; --> THE UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

;     (- (REDUCE #'MAX SEQUENCE) (REDUCE #'MIN SEQUENCE))
; 
; 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 T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

; in: DEFUN PERCENTILE
;     (COPY-SEQ SEQUENCE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS VECTOR SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS VECTOR SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS VECTOR SB-KERNEL:EXTENDED-SEQUENCE), not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (SORT (COPY-SEQ SEQUENCE) #'<)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS (SIMPLE-ARRAY * (*)) SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.

;     (COERCE (SORT (COPY-SEQ SEQUENCE) #'<) 'SIMPLE-VECTOR)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (AND (SIMPLE-ARRAY * (*)) (NOT (ARRAY T))) CONS SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR (AND (SIMPLE-ARRAY * (*)) (NOT (ARRAY T))) CONS SB-KERNEL:EXTENDED-SEQUENCE), not a (OR NULL (SIMPLE-ARRAY * (*))).
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR (AND (SIMPLE-ARRAY * (*)) (NOT (ARRAY T))) CONS SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.

;     (/ LH.STATISTICS::PERCENT 100)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL (0) 100), not a INTEGER.The result is a (VALUES (OR (FLOAT 0.0 1.0) (RATIONAL (0) 1)) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (REAL (0) 100), not a INTEGER.

;     (= LH.STATISTICS::K LH.STATISTICS::FLOOR-K)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (RATIONAL 0 17592186044415) (SINGLE-FLOAT 0.0 1.7592186e13) (DOUBLE-FLOAT 0.0d0 1.7592186044415d13)), not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (RATIONAL 0 17592186044415) (SINGLE-FLOAT 0.0 1.7592186e13) (DOUBLE-FLOAT 0.0d0 1.7592186044415d13)), not a DOUBLE-FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (FLOOR LH.STATISTICS::K)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (RATIONAL 0 17592186044415) (SINGLE-FLOAT 0.0 1.7592186e13) (DOUBLE-FLOAT 0.0d0 1.7592186044415d13)), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (RATIONAL 0 17592186044415) (SINGLE-FLOAT 0.0 1.7592186e13) (DOUBLE-FLOAT 0.0d0 1.7592186044415d13)), not a DOUBLE-FLOAT.

;     (/
;      (+ (AREF LH.STATISTICS::SORTED-VECT LH.STATISTICS::K)
;         (AREF LH.STATISTICS::SORTED-VECT (1- LH.STATISTICS::K)))
;      2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.

;     (LH.STATISTICS:TEST-VARIABLES (SEQUENCE :NUMSEQ)
;                                   (LH.STATISTICS::PERCENT :PERCENTAGE))
; --> LET UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

;     (* LH.STATISTICS::N (/ LH.STATISTICS::PERCENT 100))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (OR (FLOAT 0.0 1.0) (RATIONAL (0) 1)), not a FIXNUM.
;       The result is a (VALUES (OR (RATIONAL 0 17592186044415) (SINGLE-FLOAT 0.0 1.7592186e13) (DOUBLE-FLOAT 0.0d0 1.7592186044415d13)) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (OR (FLOAT 0.0 1.0) (RATIONAL (0) 1)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (OR (RATIONAL 0 17592186044415) (SINGLE-FLOAT 0.0 1.7592186e13) (DOUBLE-FLOAT 0.0d0 1.7592186044415d13)) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ (AREF LH.STATISTICS::SORTED-VECT LH.STATISTICS::K)
;        (AREF LH.STATISTICS::SORTED-VECT (1- LH.STATISTICS::K)))
; 
; 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 T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

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

;     (/
;      (REDUCE #'+
;              (MAP 'LIST #'(LAMBDA (LH.STATISTICS::X) (LH.STATISTICS:SQUARE #))
;                   SEQUENCE))
;      (1- LH.STATISTICS::N))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (LH.STATISTICS:TEST-VARIABLES (SEQUENCE :NUMSEQ))
; --> THE UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

;     (- LH.STATISTICS:MEAN LH.STATISTICS::X)
; 
; 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 T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       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 &OPTIONAL).
;       etc.
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE (- LH.STATISTICS:MEAN LH.STATISTICS::X))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN STANDARD-DEVIATION
;     (LENGTH SEQUENCE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS VECTOR SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

;     (/
;      (REDUCE #'+
;              (MAP 'LIST #'(LAMBDA (LH.STATISTICS::X) (LH.STATISTICS:SQUARE #))
;                   SEQUENCE))
;      (1- LH.STATISTICS::N))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (SQRT
;      (/ (REDUCE #'+ (MAP 'LIST #'(LAMBDA # #) SEQUENCE)) (1- LH.STATISTICS::N)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-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 (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (LH.STATISTICS:TEST-VARIABLES (SEQUENCE :NUMSEQ))
; --> THE UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

;     (- LH.STATISTICS:MEAN LH.STATISTICS::X)
; 
; 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 T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       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 &OPTIONAL).
;       etc.
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE (- LH.STATISTICS:MEAN LH.STATISTICS::X))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

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

;     (/
;      (REDUCE #'+
;              (MAP 'LIST #'(LAMBDA (LH.STATISTICS::X) (LH.STATISTICS:SQUARE #))
;                   SEQUENCE))
;      (1- LH.STATISTICS::N))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (SQRT
;      (/ (REDUCE #'+ (MAP 'LIST #'(LAMBDA # #) SEQUENCE)) (1- LH.STATISTICS::N)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-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 (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (LH.STATISTICS:TEST-VARIABLES (SEQUENCE :NUMSEQ))
; --> THE UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

;     (- LH.STATISTICS:MEAN LH.STATISTICS::X)
; 
; 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 T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       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 &OPTIONAL).
;       etc.
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE (- LH.STATISTICS:MEAN LH.STATISTICS::X))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN COEFFICIENT-OF-VARIATION
;     (/ (LH.STATISTICS:STANDARD-DEVIATION SEQUENCE) (LH.STATISTICS:MEAN SEQUENCE))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

; in: DEFUN STANDARD-ERROR-OF-THE-MEAN
;     (LENGTH SEQUENCE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (/ (LH.STATISTICS:STANDARD-DEVIATION SEQUENCE) (SQRT (LENGTH SEQUENCE)))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).

; in: DEFUN BINOMIAL-PROBABILITY
;     (>= LH.STATISTICS::K 0)
; 
; 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.

;     (<= LH.STATISTICS::K LH.STATISTICS::N)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0), not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0), not a DOUBLE-FLOAT.

;     (< LH.STATISTICS::P 0.01)
; 
; note: unable to open-code RATIONAL to FLOAT comparison due to type uncertainty: The first argument is a (REAL 0 1), not a RATIONAL.

;     (EXPT LH.STATISTICS::P LH.STATISTICS::K)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (REAL 0), not a DOUBLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The second argument is a (REAL 0), not a INTEGER.

;     (EXPT (- 1 LH.STATISTICS::P) (- LH.STATISTICS::N LH.STATISTICS::K))
; 
; note: unable to optimize due to type uncertainty: The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The second argument is a REAL, not a INTEGER.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::N :POSINT)
;                                   (LH.STATISTICS::P :PROB)
;                                   ("K must be between 0 and N (inclusive)" :TEST
;                                    (AND (>= LH.STATISTICS::K 0)
;                                         (<= LH.STATISTICS::K LH.STATISTICS::N))))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   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.

;     (< LH.STATISTICS::P 0.01)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL 0 1), not a SINGLE-FLOAT.

;     (* LH.STATISTICS::N LH.STATISTICS::P)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 101), not a FIXNUM.
;       The second argument is a (REAL 0 (5368709/536870912)), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 101), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 (5368709/536870912)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (COERCE LH.STATISTICS::P 'DOUBLE-FLOAT)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (REAL 0 1), not a (SIGNED-BYTE 64).

;     (* (LH.STATISTICS:CHOOSE LH.STATISTICS::N LH.STATISTICS::K)
;        (EXPT LH.STATISTICS::P LH.STATISTICS::K)
;        (EXPT (- 1 LH.STATISTICS::P) (- LH.STATISTICS::N LH.STATISTICS::K)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (- LH.STATISTICS::N LH.STATISTICS::K)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* (LH.STATISTICS:CHOOSE LH.STATISTICS::N LH.STATISTICS::K)
;        (EXPT LH.STATISTICS::P LH.STATISTICS::K)
;        (EXPT (- 1 LH.STATISTICS::P) (- LH.STATISTICS::N LH.STATISTICS::K)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (EXPT LH.STATISTICS::P LH.STATISTICS::K)
; 
; note: doing float to pointer coercion (cost 13)

;     (EXPT (- 1 LH.STATISTICS::P) (- LH.STATISTICS::N LH.STATISTICS::K))
; 
; note: doing float to pointer coercion (cost 13)

; in: DEFUN BINOMIAL-CUMULATIVE-PROBABILITY
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::N :POSINT)
;                                   (LH.STATISTICS::K :POSINT)
;                                   (LH.STATISTICS::P :PROB)
;                                   ("K must be less than or equal to N" :TEST
;                                    (<= LH.STATISTICS::K LH.STATISTICS::N)))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   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.

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

;     (<= LH.STATISTICS::K LH.STATISTICS::N)
; 
; 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 1), not a FIXNUM.

;     (DOTIMES (LH.STATISTICS::I LH.STATISTICS::K LH.STATISTICS::SUM-UP-TO-K-1)
;       (INCF LH.STATISTICS::SUM-UP-TO-K-1
;             (LH.STATISTICS:BINOMIAL-PROBABILITY LH.STATISTICS::N LH.STATISTICS::I
;              LH.STATISTICS::P)))
; --> BLOCK LET TAGBODY UNLESS IF >= 
; ==>
;   1
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a (INTEGER 1), not a FIXNUM.

;     (INCF LH.STATISTICS::SUM-UP-TO-K-1
;           (LH.STATISTICS:BINOMIAL-PROBABILITY LH.STATISTICS::N LH.STATISTICS::I
;            LH.STATISTICS::P))
; --> THE 
; ==>
;   (+
;    (LH.STATISTICS:BINOMIAL-PROBABILITY LH.STATISTICS::N LH.STATISTICS::I
;     LH.STATISTICS::P)
;    LH.STATISTICS::SUM-UP-TO-K-1)
; 
; 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 (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (DOTIMES (LH.STATISTICS::I LH.STATISTICS::K LH.STATISTICS::SUM-UP-TO-K-1)
;       (INCF LH.STATISTICS::SUM-UP-TO-K-1
;             (LH.STATISTICS:BINOMIAL-PROBABILITY LH.STATISTICS::N LH.STATISTICS::I
;              LH.STATISTICS::P)))
; --> BLOCK LET TAGBODY PSETQ PROGN SETQ THE 1+ 
; ==>
;   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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

; in: DEFUN BINOMIAL-LE-PROBABILITY
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::N :POSINT)
;                                   (LH.STATISTICS::K :POSINT)
;                                   (LH.STATISTICS::P :PROB)
;                                   ("K must be less than or equal to N" :TEST
;                                    (<= LH.STATISTICS::K LH.STATISTICS::N)))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   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.

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

;     (<= LH.STATISTICS::K LH.STATISTICS::N)
; 
; 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 1), not a FIXNUM.

;     (1+ LH.STATISTICS::K)
; 
; 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 (INTEGER 2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (DOTIMES (LH.STATISTICS::I (1+ LH.STATISTICS::K) LH.STATISTICS::SUM-UP-TO-K)
;       (INCF LH.STATISTICS::SUM-UP-TO-K
;             (LH.STATISTICS:BINOMIAL-PROBABILITY LH.STATISTICS::N LH.STATISTICS::I
;              LH.STATISTICS::P)))
; --> BLOCK LET TAGBODY UNLESS IF >= 
; ==>
;   1
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a (INTEGER 2), not a FIXNUM.

;     (INCF LH.STATISTICS::SUM-UP-TO-K
;           (LH.STATISTICS:BINOMIAL-PROBABILITY LH.STATISTICS::N LH.STATISTICS::I
;            LH.STATISTICS::P))
; --> THE 
; ==>
;   (+
;    (LH.STATISTICS:BINOMIAL-PROBABILITY LH.STATISTICS::N LH.STATISTICS::I
;     LH.STATISTICS::P)
;    LH.STATISTICS::SUM-UP-TO-K)
; 
; 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 (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (DOTIMES (LH.STATISTICS::I (1+ LH.STATISTICS::K) LH.STATISTICS::SUM-UP-TO-K)
;       (INCF LH.STATISTICS::SUM-UP-TO-K
;             (LH.STATISTICS:BINOMIAL-PROBABILITY LH.STATISTICS::N LH.STATISTICS::I
;              LH.STATISTICS::P)))
; --> BLOCK LET TAGBODY PSETQ PROGN SETQ THE 1+ 
; ==>
;   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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

; in: DEFUN POISSON-PROBABILITY
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::MU :POSNUM)
;                                   (LH.STATISTICS::K :POSINT))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

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

;     (COERCE LH.STATISTICS::MU 'DOUBLE-FLOAT)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a (REAL (0)), not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (REAL (0)), not a (SIGNED-BYTE 64).

;     (EXPT LH.STATISTICS::MU LH.STATISTICS::K)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (INTEGER 4611686018427387904), not a (SIGNED-BYTE 64).

;     (/ (* (EXP (- LH.STATISTICS::MU)) (EXPT LH.STATISTICS::MU LH.STATISTICS::K))
;        (LH.STATISTICS::FACTORIAL LH.STATISTICS::K))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) because:
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
; 
; note: doing float to pointer coercion (cost 13)

; in: DEFUN POISSON-CUMULATIVE-PROBABILITY
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::MU :POSNUM)
;                                   (LH.STATISTICS::K :POSINT))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

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

;     (INCF LH.STATISTICS::SUM
;           (LH.STATISTICS:POISSON-PROBABILITY LH.STATISTICS::MU LH.STATISTICS::X))
; --> THE 
; ==>
;   (+ (LH.STATISTICS:POISSON-PROBABILITY LH.STATISTICS::MU LH.STATISTICS::X)
;      LH.STATISTICS::SUM)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (COERCE LH.STATISTICS::MU 'DOUBLE-FLOAT)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a (REAL (0)), not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (REAL (0)), not a (SIGNED-BYTE 64).

;     (COERCE LH.STATISTICS::K 'DOUBLE-FLOAT)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (INTEGER 4611686018427387904), not a (SIGNED-BYTE 64).

;     (- 1.0d0 (LH.STATISTICS::GAMMA-INCOMPLETE LH.STATISTICS::K LH.STATISTICS::MU))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The second argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (LH.STATISTICS::GAMMA-INCOMPLETE LH.STATISTICS::K LH.STATISTICS::MU)
; 
; note: doing float to pointer coercion (cost 13)
; 
; note: doing float to pointer coercion (cost 13)

; in: DEFUN NORMAL-PDF
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::X NUMBER)
;                                   (LH.STATISTICS::MU NUMBER)
;                                   (LH.STATISTICS::SIGMA :POSNUM))
; --> LET IF LET IF UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

;     (* 2 (LH.STATISTICS:SQUARE LH.STATISTICS::SIGMA))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a DOUBLE-FLOAT.
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a (REAL 0), not a INTEGER.

;     (/ (* 2 (LH.STATISTICS:SQUARE LH.STATISTICS::SIGMA)))
; 
; note: unable to optimize due to type uncertainty: The second argument is a (REAL 0), not a INTEGER.The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (- (/ (* 2 (LH.STATISTICS:SQUARE LH.STATISTICS::SIGMA))))
; 
; note: unable to Eliminate %negate/%negate of rationals due to type uncertainty: The first argument is a (REAL 0), not a RATIONAL.

;     (EXP
;      (* (- (/ (* 2 #)))
;         (LH.STATISTICS:SQUARE (- LH.STATISTICS::X LH.STATISTICS::MU))))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::X NUMBER)
;                                   (LH.STATISTICS::MU NUMBER)
;                                   (LH.STATISTICS::SIGMA :POSNUM))
; --> LET IF LET IF UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

;     (* (SQRT (* 2 PI)) LH.STATISTICS::SIGMA)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a (REAL (0)), not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (REAL (0)), not a (SIGNED-BYTE 64).

;     (LH.STATISTICS:SQUARE LH.STATISTICS::SIGMA)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The second argument is a (REAL (0)), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 (LH.STATISTICS:SQUARE LH.STATISTICS::SIGMA))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- (/ (* 2 (LH.STATISTICS:SQUARE LH.STATISTICS::SIGMA))))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL * 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL * 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::X LH.STATISTICS::MU)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE (- LH.STATISTICS::X LH.STATISTICS::MU))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* (- (/ (* 2 (LH.STATISTICS:SQUARE LH.STATISTICS::SIGMA))))
;        (LH.STATISTICS:SQUARE (- LH.STATISTICS::X LH.STATISTICS::MU)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL * 0), not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL * 0), not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* (/ (* (SQRT (* 2 PI)) LH.STATISTICS::SIGMA))
;        (EXP
;         (* (- (/ #))
;            (LH.STATISTICS:SQUARE (- LH.STATISTICS::X LH.STATISTICS::MU)))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The second argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The second argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first argument of GENERIC-*

; in: DEFUN CONVERT-TO-STANDARD-NORMAL
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::X NUMBER)
;                                   (LH.STATISTICS::MU NUMBER)
;                                   (LH.STATISTICS::SIGMA :POSNUM))
; --> LET IF LET IF UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

;     (/ (- LH.STATISTICS::X LH.STATISTICS::MU) LH.STATISTICS::SIGMA)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a (REAL (0)), not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::X NUMBER)
;                                   (LH.STATISTICS::MU NUMBER)
;                                   (LH.STATISTICS::SIGMA :POSNUM))
; --> LET IF LET IF UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

;     (- LH.STATISTICS::X LH.STATISTICS::MU)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (/ (- LH.STATISTICS::X LH.STATISTICS::MU) LH.STATISTICS::SIGMA)
; 
; 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 (REAL (0)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 (REAL (0)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

; in: DEFUN PHI
;     (COERCE LH.STATISTICS::X 'DOUBLE-FLOAT)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).

;     (+ 1.0d0 (LH.STATISTICS::ERROR-FUNCTION (/ LH.STATISTICS::X (SQRT 2.0d0))))
; 
; 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 result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* 0.5d0
;        (+ 1.0d0
;           (LH.STATISTICS::ERROR-FUNCTION (/ LH.STATISTICS::X (SQRT 2.0d0)))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (SETF LH.STATISTICS::X (COERCE LH.STATISTICS::X 'DOUBLE-FLOAT))
; 
; note: doing float to pointer coercion (cost 13) to X

;     (LH.STATISTICS::ERROR-FUNCTION (/ LH.STATISTICS::X (SQRT 2.0d0)))
; 
; note: doing float to pointer coercion (cost 13)

; in: DEFUN Z
;     (< (- MAX MIN) LH.STATISTICS::EPSILON)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The second argument is a REAL, not a RATIONAL.

;     (/ (- MAX MIN) 2.0d0)
; 
; note: unable to convert to multiplication by reciprocal due to type uncertainty: The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.

;     (COERCE LH.STATISTICS:PERCENTILE 'DOUBLE-FLOAT)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (REAL 0 1), not a (SIGNED-BYTE 64).

;     (- MAX MIN)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (< (- MAX MIN) LH.STATISTICS::EPSILON)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.

;     (- MAX MIN)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (/ (- MAX MIN) 2.0d0)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (+ MIN (/ (- MAX MIN) 2.0d0))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

; in: DEFUN T-DISTRIBUTION
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::DOF :POSINT)
;                                   (LH.STATISTICS:PERCENTILE :PROB))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   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.

;     (- 1 LH.STATISTICS:PERCENTILE)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN CHI-SQUARE
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::DOF :POSINT)
;                                   (LH.STATISTICS:PERCENTILE :PROB))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   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.

;     (- 1 LH.STATISTICS:PERCENTILE)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN CHI-SQUARE-CDF
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::X :POSNUM)
;                                   (LH.STATISTICS::DOF :POSINT))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

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

;     (* 0.5 LH.STATISTICS::DOF)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (INTEGER 4611686018427387904), not a (SIGNED-BYTE 64).

;     (* 0.5 LH.STATISTICS::X)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (FLOAT 0.0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).

; in: DEFUN BINOMIAL-PROBABILITY-CI
;     (FLOOR (* LH.STATISTICS::P LH.STATISTICS::N))
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to convert division by 2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to fold division by 1 due to type uncertainty: The first argument is a REAL, not a INTEGER.

;     (> (* LH.STATISTICS::N LH.STATISTICS::P (- 1 LH.STATISTICS::P)) 10)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0), not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0), not a DOUBLE-FLOAT.

;     (/ LH.STATISTICS::ALPHA 2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1/2) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.

;     (/ (* LH.STATISTICS::P (- 1 LH.STATISTICS::P)) LH.STATISTICS::N)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (SQRT (/ (* LH.STATISTICS::P (- 1 LH.STATISTICS::P)) LH.STATISTICS::N))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a DOUBLE-FLOAT.

;     (/ LH.STATISTICS::ALPHA 2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1/2) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1/2) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.

;     (FLOOR (* LH.STATISTICS::P LH.STATISTICS::N))
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to convert division by 2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to fold division by 1 due to type uncertainty: The first argument is a REAL, not a INTEGER.

;     (* LH.STATISTICS::P LH.STATISTICS::N)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (1+ (FLOOR (* LH.STATISTICS::P LH.STATISTICS::N)))
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::N :POSINT)
;                                   (LH.STATISTICS::P :PROB)
;                                   (LH.STATISTICS::ALPHA :PROB))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   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.

;     (* LH.STATISTICS::N LH.STATISTICS::P (- 1 LH.STATISTICS::P))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- 1 LH.STATISTICS::P)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::N LH.STATISTICS::P (- 1 LH.STATISTICS::P))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (> (* LH.STATISTICS::N LH.STATISTICS::P (- 1 LH.STATISTICS::P)) 10)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       etc.

;     (- 1 (/ LH.STATISTICS::ALPHA 2))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1/2), not a FIXNUM.
;       The result is a (VALUES (REAL 1/2 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1/2), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 1/2 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- 1 LH.STATISTICS::P)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P (- 1 LH.STATISTICS::P))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* (LH.STATISTICS:Z (- 1 (/ LH.STATISTICS::ALPHA 2)))
;        (SQRT (/ (* LH.STATISTICS::P (- 1 LH.STATISTICS::P)) LH.STATISTICS::N)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (FLOAT 0.0 1.0), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (FLOAT 0.0 1.0), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (- LH.STATISTICS::P LH.STATISTICS::DIFFERENCE)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (+ LH.STATISTICS::P LH.STATISTICS::DIFFERENCE)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (- 1 (/ LH.STATISTICS::ALPHA 2))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1/2), not a FIXNUM.
;       The result is a (VALUES (REAL 1/2 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1/2), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 1/2 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN POISSON-MU-CI
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::X :POSNUM)
;                                   (LH.STATISTICS::ALPHA :PROB))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

;     (/ LH.STATISTICS::ALPHA 2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1/2) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1/2) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.

;     (1- LH.STATISTICS::X)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::X :POSNUM)
;                                   (LH.STATISTICS::ALPHA :PROB))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

;     (- 1 (/ LH.STATISTICS::ALPHA 2))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1/2), not a FIXNUM.
;       The result is a (VALUES (REAL 1/2 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1/2), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 1/2 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN NORMAL-MEAN-CI
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS:MEAN NUMBER)
;                                   (LH.STATISTICS:SD :POSNUM)
;                                   (LH.STATISTICS::N :POSINT)
;                                   (LH.STATISTICS::ALPHA :PROB))
; --> LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

;     (/ LH.STATISTICS::ALPHA 2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1/2) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS:MEAN NUMBER)
;                                   (LH.STATISTICS:SD :POSNUM)
;                                   (LH.STATISTICS::N :POSINT)
;                                   (LH.STATISTICS::ALPHA :PROB))
; --> LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

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

;     (1- LH.STATISTICS::N)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (- 1 (/ LH.STATISTICS::ALPHA 2))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1/2), not a FIXNUM.
;       The result is a (VALUES (REAL 1/2 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1/2), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 1/2 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/ LH.STATISTICS:SD (SQRT LH.STATISTICS::N))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (FLOAT 0.0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).

;     (* LH.STATISTICS::T-VALUE (/ LH.STATISTICS:SD (SQRT LH.STATISTICS::N)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a (FLOAT 0.0), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 (FLOAT 0.0), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (- LH.STATISTICS:MEAN
;        (* LH.STATISTICS::T-VALUE (/ LH.STATISTICS:SD (SQRT LH.STATISTICS::N))))
; 
; note: forced to do GENERIC-- (cost 10)
;       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 FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (/ LH.STATISTICS:SD (SQRT LH.STATISTICS::N))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (FLOAT 0.0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).

;     (* LH.STATISTICS::T-VALUE (/ LH.STATISTICS:SD (SQRT LH.STATISTICS::N)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a (FLOAT 0.0), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 (FLOAT 0.0), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS:MEAN
;        (* LH.STATISTICS::T-VALUE (/ LH.STATISTICS:SD (SQRT LH.STATISTICS::N))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

; in: DEFUN NORMAL-VARIANCE-CI
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS:VARIANCE :POSNUM)
;                                   (LH.STATISTICS::N :POSINT)
;                                   (LH.STATISTICS::ALPHA :PROB))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

;     (/ LH.STATISTICS::ALPHA 2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1/2) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1/2) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.

;     (/ NUMERATOR LH.STATISTICS::CHI-SQUARE-LOW)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a INTEGER.The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (/ NUMERATOR LH.STATISTICS::CHI-SQUARE-HIGH)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a INTEGER.The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS:VARIANCE :POSNUM)
;                                   (LH.STATISTICS::N :POSINT)
;                                   (LH.STATISTICS::ALPHA :PROB))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

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

;     (1- LH.STATISTICS::N)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (- 1 (/ LH.STATISTICS::ALPHA 2))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1/2), not a FIXNUM.
;       The result is a (VALUES (REAL 1/2 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1/2), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 1/2 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (1- LH.STATISTICS::N)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (* (1- LH.STATISTICS::N) LH.STATISTICS:VARIANCE)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a (REAL (0)), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/ NUMERATOR LH.STATISTICS::CHI-SQUARE-LOW)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL 0), 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 &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (REAL 0), 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 &OPTIONAL).

;     (/ NUMERATOR LH.STATISTICS::CHI-SQUARE-HIGH)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL 0), 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 &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (REAL 0), 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 &OPTIONAL).

; in: DEFUN NORMAL-VARIANCE-CI-ON-SEQUENCE
;     (LENGTH SEQUENCE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS VECTOR SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

;     (LH.STATISTICS:TEST-VARIABLES (SEQUENCE :NUMSEQ) (LH.STATISTICS::ALPHA :PROB))
; --> LET UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFUN NORMAL-SD-CI
;     (SQRT LH.STATISTICS::LOW)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-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 (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (SQRT LH.STATISTICS::HIGH)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-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 (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (LH.STATISTICS:SQUARE LH.STATISTICS:SD)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN NORMAL-SD-CI-ON-SEQUENCE
;     (LENGTH SEQUENCE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS VECTOR SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

;     (LH.STATISTICS:TEST-VARIABLES (SEQUENCE :NUMSEQ) (LH.STATISTICS::ALPHA :PROB))
; --> LET UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFUN Z-TEST
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::X-BAR NUMBER)
;                                   (LH.STATISTICS::N :POSINT)
;                                   (LH.STATISTICS::MU NUMBER)
;                                   (LH.STATISTICS::SIGMA :POSNUM))
; --> LET IF LET IF LET IF UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

;     (* 2 (LH.STATISTICS:PHI LH.STATISTICS:Z))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.

;     (* 2 (- 1 (LH.STATISTICS:PHI LH.STATISTICS:Z)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::X-BAR NUMBER)
;                                   (LH.STATISTICS::N :POSINT)
;                                   (LH.STATISTICS::MU NUMBER)
;                                   (LH.STATISTICS::SIGMA :POSNUM))
; --> LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   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.

; --> LET IF LET IF LET IF UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

;     (- LH.STATISTICS::X-BAR LH.STATISTICS::MU)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (/ LH.STATISTICS::SIGMA (SQRT LH.STATISTICS::N))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (FLOAT 0.0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).

;     (/ (- LH.STATISTICS::X-BAR LH.STATISTICS::MU)
;        (/ LH.STATISTICS::SIGMA (SQRT LH.STATISTICS::N)))
; 
; 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 (FLOAT 0.0), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 (FLOAT 0.0), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

; in: DEFUN Z-TEST-ON-SEQUENCE
;     (LENGTH SEQUENCE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS VECTOR SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

;     (LH.STATISTICS:TEST-VARIABLES (SEQUENCE :NUMSEQ))
; --> THE UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFUN T-TEST-ONE-SAMPLE
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::X-BAR NUMBER)
;                                   (LH.STATISTICS:SD :POSNUM)
;                                   (LH.STATISTICS::N :POSINT)
;                                   (LH.STATISTICS::MU NUMBER))
; --> LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

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

;     (- LH.STATISTICS::X-BAR LH.STATISTICS::MU)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (/ LH.STATISTICS:SD (SQRT LH.STATISTICS::N))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (FLOAT 0.0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).

;     (/ (- LH.STATISTICS::X-BAR LH.STATISTICS::MU)
;        (/ LH.STATISTICS:SD (SQRT LH.STATISTICS::N)))
; 
; 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 (FLOAT 0.0), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 (FLOAT 0.0), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (1- LH.STATISTICS::N)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

; in: DEFUN T-TEST-PAIRED
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::D-BAR NUMBER)
;                                   (LH.STATISTICS:SD :POSNUM)
;                                   (LH.STATISTICS::N :POSINT))
; --> LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

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

;     (/ LH.STATISTICS:SD (SQRT LH.STATISTICS::N))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (FLOAT 0.0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).

;     (/ LH.STATISTICS::D-BAR (/ LH.STATISTICS:SD (SQRT LH.STATISTICS::N)))
; 
; 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 (FLOAT 0.0), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 (FLOAT 0.0), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (1- LH.STATISTICS::N)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

; in: DEFUN T-TEST-PAIRED-ON-SEQUENCES
;     (LENGTH LH.STATISTICS::BEFORE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS VECTOR SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

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

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::BEFORE :NUMSEQ)
;                                   (LH.STATISTICS::AFTER :NUMSEQ)
;                                   ("Before and after sequences must be of equal length"
;                                    :TEST
;                                    (= (LENGTH LH.STATISTICS::BEFORE)
;                                       (LENGTH LH.STATISTICS::AFTER))))
; --> LET UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

;     (MAP 'LIST #'- LH.STATISTICS::BEFORE LH.STATISTICS::AFTER)
; 
; note: unable to open code because: can't determine sequence argument type

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::BEFORE :NUMSEQ)
;                                   (LH.STATISTICS::AFTER :NUMSEQ)
;                                   ("Before and after sequences must be of equal length"
;                                    :TEST
;                                    (= (LENGTH LH.STATISTICS::BEFORE)
;                                       (LENGTH LH.STATISTICS::AFTER))))
; --> LET IF LET UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFUN T-TEST-TWO-SAMPLE
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::X-BAR1 NUMBER)
;                                   (LH.STATISTICS::SD1 :POSNUM)
;                                   (LH.STATISTICS::N1 :POSINT)
;                                   (LH.STATISTICS::X-BAR2 NUMBER)
;                                   (LH.STATISTICS::SD2 :POSNUM)
;                                   (LH.STATISTICS::N2 :POSINT))
; --> LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

; --> LET IF LET IF LET IF LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

;     (>
;      (LH.STATISTICS:F-TEST (LH.STATISTICS:SQUARE LH.STATISTICS::SD1)
;       LH.STATISTICS::N1 (LH.STATISTICS:SQUARE LH.STATISTICS::SD2)
;       LH.STATISTICS::N2 :TAILS LH.STATISTICS::TAILS)
;      LH.STATISTICS::VARIANCE-SIGNIFICANCE-CUTOFF)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.

;     (/
;      (+ (* (1- LH.STATISTICS::N1) (LH.STATISTICS:SQUARE LH.STATISTICS::SD1))
;         (* (1- LH.STATISTICS::N2) (LH.STATISTICS:SQUARE LH.STATISTICS::SD2)))
;      (+ LH.STATISTICS::N1 LH.STATISTICS::N2 -2))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a INTEGER.The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (SQRT
;      (/
;       (+ (* (1- LH.STATISTICS::N1) (LH.STATISTICS:SQUARE LH.STATISTICS::SD1))
;          (* (1- LH.STATISTICS::N2) (LH.STATISTICS:SQUARE LH.STATISTICS::SD2)))
;       (+ LH.STATISTICS::N1 LH.STATISTICS::N2 -2)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a DOUBLE-FLOAT.

;     (/ LH.STATISTICS::N1)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (RATIONAL (0) 1) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (/ LH.STATISTICS::N2)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (RATIONAL (0) 1) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (/ (LH.STATISTICS:SQUARE LH.STATISTICS::SD1) LH.STATISTICS::N1)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a INTEGER.The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (/ (LH.STATISTICS:SQUARE LH.STATISTICS::SD2) LH.STATISTICS::N2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a INTEGER.The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (SQRT (+ LH.STATISTICS::VARIANCE-RATIO1 LH.STATISTICS::VARIANCE-RATIO2))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a DOUBLE-FLOAT.

;     (/ (LH.STATISTICS:SQUARE LH.STATISTICS::VARIANCE-RATIO1)
;        (1- LH.STATISTICS::N1))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a INTEGER.The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (/ (LH.STATISTICS:SQUARE LH.STATISTICS::VARIANCE-RATIO2)
;        (1- LH.STATISTICS::N2))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a INTEGER.The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (/
;      (LH.STATISTICS:SQUARE
;       (+ LH.STATISTICS::VARIANCE-RATIO1 LH.STATISTICS::VARIANCE-RATIO2))
;      (+
;       (/ (LH.STATISTICS:SQUARE LH.STATISTICS::VARIANCE-RATIO1)
;          (1- LH.STATISTICS::N1))
;       (/ (LH.STATISTICS:SQUARE LH.STATISTICS::VARIANCE-RATIO2)
;          (1- LH.STATISTICS::N2))))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a INTEGER.The second argument is a (REAL 0), not a INTEGER.The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::X-BAR1 NUMBER)
;                                   (LH.STATISTICS::SD1 :POSNUM)
;                                   (LH.STATISTICS::N1 :POSINT)
;                                   (LH.STATISTICS::X-BAR2 NUMBER)
;                                   (LH.STATISTICS::SD2 :POSNUM)
;                                   (LH.STATISTICS::N2 :POSINT))
; --> LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

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

; --> LET IF LET IF LET IF LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

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

;     (LH.STATISTICS:SQUARE LH.STATISTICS::SD1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The second argument is a (REAL (0)), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE LH.STATISTICS::SD2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The second argument is a (REAL (0)), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (>
;      (LH.STATISTICS:F-TEST (LH.STATISTICS:SQUARE LH.STATISTICS::SD1)
;       LH.STATISTICS::N1 (LH.STATISTICS:SQUARE LH.STATISTICS::SD2)
;       LH.STATISTICS::N2 :TAILS LH.STATISTICS::TAILS)
;      LH.STATISTICS::VARIANCE-SIGNIFICANCE-CUTOFF)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       etc.

;     (1- LH.STATISTICS::N1)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE LH.STATISTICS::SD1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The second argument is a (REAL (0)), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* (1- LH.STATISTICS::N1) (LH.STATISTICS:SQUARE LH.STATISTICS::SD1))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (1- LH.STATISTICS::N2)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE LH.STATISTICS::SD2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The second argument is a (REAL (0)), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* (1- LH.STATISTICS::N2) (LH.STATISTICS:SQUARE LH.STATISTICS::SD2))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ (* (1- LH.STATISTICS::N1) (LH.STATISTICS:SQUARE LH.STATISTICS::SD1))
;        (* (1- LH.STATISTICS::N2) (LH.STATISTICS:SQUARE LH.STATISTICS::SD2)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::N1 LH.STATISTICS::N2 -2)
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 1), not a FIXNUM.
;       The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER 2), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 2), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::X-BAR1 LH.STATISTICS::X-BAR2)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (+ (/ LH.STATISTICS::N1) (/ LH.STATISTICS::N2))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL (0) 1), not a FIXNUM.
;       The second argument is a (RATIONAL (0) 1), not a FIXNUM.
;       The result is a (VALUES (RATIONAL (0) 2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (RATIONAL (0) 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (RATIONAL (0) 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (RATIONAL (0) 2) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::S (SQRT (+ (/ LH.STATISTICS::N1) (/ LH.STATISTICS::N2))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (FLOAT 0.0), not a SINGLE-FLOAT.
;       The result is a (VALUES (FLOAT 0.0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).

;     (/ (- LH.STATISTICS::X-BAR1 LH.STATISTICS::X-BAR2)
;        (* LH.STATISTICS::S
;           (SQRT (+ (/ LH.STATISTICS::N1) (/ LH.STATISTICS::N2)))))
; 
; 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 (FLOAT 0.0), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 (FLOAT 0.0), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::N1 LH.STATISTICS::N2 -2)
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 1), not a FIXNUM.
;       The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER 2), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 2), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE LH.STATISTICS::SD1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The second argument is a (REAL (0)), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE LH.STATISTICS::SD2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The second argument is a (REAL (0)), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::X-BAR1 LH.STATISTICS::X-BAR2)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::VARIANCE-RATIO1 LH.STATISTICS::VARIANCE-RATIO2)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (/ (- LH.STATISTICS::X-BAR1 LH.STATISTICS::X-BAR2)
;        (SQRT (+ LH.STATISTICS::VARIANCE-RATIO1 LH.STATISTICS::VARIANCE-RATIO2)))
; 
; 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 (FLOAT 0.0), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 (FLOAT 0.0), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::VARIANCE-RATIO1 LH.STATISTICS::VARIANCE-RATIO2)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE
;      (+ LH.STATISTICS::VARIANCE-RATIO1 LH.STATISTICS::VARIANCE-RATIO2))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE LH.STATISTICS::VARIANCE-RATIO1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (1- LH.STATISTICS::N1)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE LH.STATISTICS::VARIANCE-RATIO2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (1- LH.STATISTICS::N2)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (+
;      (/ (LH.STATISTICS:SQUARE LH.STATISTICS::VARIANCE-RATIO1)
;         (1- LH.STATISTICS::N1))
;      (/ (LH.STATISTICS:SQUARE LH.STATISTICS::VARIANCE-RATIO2)
;         (1- LH.STATISTICS::N2)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (/
;      (LH.STATISTICS:SQUARE
;       (+ LH.STATISTICS::VARIANCE-RATIO1 LH.STATISTICS::VARIANCE-RATIO2))
;      (+
;       (/ (LH.STATISTICS:SQUARE LH.STATISTICS::VARIANCE-RATIO1)
;          (1- LH.STATISTICS::N1))
;       (/ (LH.STATISTICS:SQUARE LH.STATISTICS::VARIANCE-RATIO2)
;          (1- LH.STATISTICS::N2))))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (REAL 0), not a DOUBLE-FLOAT.
;       The second argument is a (REAL 0), not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (ROUND
;      (/
;       (LH.STATISTICS:SQUARE
;        (+ LH.STATISTICS::VARIANCE-RATIO1 LH.STATISTICS::VARIANCE-RATIO2))
;       (+
;        (/ (LH.STATISTICS:SQUARE LH.STATISTICS::VARIANCE-RATIO1)
;           (1- LH.STATISTICS::N1))
;        (/ (LH.STATISTICS:SQUARE LH.STATISTICS::VARIANCE-RATIO2)
;           (1- LH.STATISTICS::N2)))))
; 
; note: forced to do full call
;       unable to do inline float truncate (cost 5) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &OPTIONAL).
;       unable to do inline float truncate (cost 5) because:
;       The first argument is a (REAL 0), not a DOUBLE-FLOAT.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &OPTIONAL).

; in: DEFUN F-TEST
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::VARIANCE1 :POSNUM)
;                                   (LH.STATISTICS::N1 :POSINT)
;                                   (LH.STATISTICS::VARIANCE2 :POSNUM)
;                                   (LH.STATISTICS::N2 :POSINT))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

; --> LET IF LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

;     (/ LH.STATISTICS::VARIANCE1 LH.STATISTICS::VARIANCE2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL (0)), not a INTEGER.The second argument is a (REAL (0)), not a INTEGER.The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (> LH.STATISTICS::VARIANCE1 LH.STATISTICS::VARIANCE2)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL (0)), not a SINGLE-FLOAT.The second argument is a (REAL (0)), not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL (0)), not a DOUBLE-FLOAT.The second argument is a (REAL (0)), not a RATIONAL.

;     (< LH.STATISTICS::VARIANCE1 LH.STATISTICS::VARIANCE2)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL (0)), not a SINGLE-FLOAT.The second argument is a (REAL (0)), not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL (0)), not a DOUBLE-FLOAT.The second argument is a (REAL (0)), not a RATIONAL.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::VARIANCE1 :POSNUM)
;                                   (LH.STATISTICS::N1 :POSINT)
;                                   (LH.STATISTICS::VARIANCE2 :POSNUM)
;                                   (LH.STATISTICS::N2 :POSINT))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

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

; --> LET IF LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

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

;     (/ LH.STATISTICS::VARIANCE1 LH.STATISTICS::VARIANCE2)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The second argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       The second argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (1- LH.STATISTICS::N1)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (1- LH.STATISTICS::N2)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (< LH.STATISTICS::VARIANCE1 LH.STATISTICS::VARIANCE2)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The second argument is a (REAL (0)), not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       The second argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       etc.

;     (- 1 LH.STATISTICS::SIGNIFICANCE)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (> LH.STATISTICS::VARIANCE1 LH.STATISTICS::VARIANCE2)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The second argument is a (REAL (0)), not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       The second argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       etc.

;     (- 1 LH.STATISTICS::SIGNIFICANCE)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN CHI-SQUARE-TEST-ONE-SAMPLE
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS:VARIANCE :POSNUM)
;                                   (LH.STATISTICS::N :POSINT)
;                                   (LH.STATISTICS::SIGMA-SQUARED :POSNUM))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

; --> LET IF LET IF UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

;     (/ (* (1- LH.STATISTICS::N) LH.STATISTICS:VARIANCE)
;        LH.STATISTICS::SIGMA-SQUARED)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a INTEGER.The second argument is a (REAL (0)), not a INTEGER.The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (<= LH.STATISTICS:VARIANCE LH.STATISTICS::SIGMA-SQUARED)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL (0)), not a SINGLE-FLOAT.The second argument is a (REAL (0)), not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL (0)), not a DOUBLE-FLOAT.The second argument is a (REAL (0)), not a RATIONAL.

;     (* 2 LH.STATISTICS::CDF)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.

;     (* 2 (- 1 LH.STATISTICS::CDF))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS:VARIANCE :POSNUM)
;                                   (LH.STATISTICS::N :POSINT)
;                                   (LH.STATISTICS::SIGMA-SQUARED :POSNUM))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

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

; --> LET IF LET IF UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

;     (1- LH.STATISTICS::N)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (* (1- LH.STATISTICS::N) LH.STATISTICS:VARIANCE)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a (REAL (0)), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/ (* (1- LH.STATISTICS::N) LH.STATISTICS:VARIANCE)
;        LH.STATISTICS::SIGMA-SQUARED)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       The second argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (REAL 0), not a DOUBLE-FLOAT.
;       The second argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (1- LH.STATISTICS::N)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (<= LH.STATISTICS:VARIANCE LH.STATISTICS::SIGMA-SQUARED)
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The second argument is a (REAL (0)), not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       The second argument is a (REAL (0)), not a DOUBLE-FLOAT.

;     (- 1 LH.STATISTICS::CDF)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 (- 1 LH.STATISTICS::CDF))
; 
; note: forced to do GENERIC-* (cost 30)
;       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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (* 2 LH.STATISTICS::CDF)
; 
; note: forced to do GENERIC-* (cost 30)
;       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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (- 1 LH.STATISTICS::CDF)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN BINOMIAL-TEST-ONE-SAMPLE
;     (> (* LH.STATISTICS::N LH.STATISTICS::P LH.STATISTICS::Q) 10)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0), not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0), not a DOUBLE-FLOAT.

;     (/ (* LH.STATISTICS::P LH.STATISTICS::Q) LH.STATISTICS::N)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (SQRT (/ (* LH.STATISTICS::P LH.STATISTICS::Q) LH.STATISTICS::N))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a DOUBLE-FLOAT.

;     (<= LH.STATISTICS::P-HAT LH.STATISTICS::P)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0 1), not a SINGLE-FLOAT.The second argument is a (REAL 0 1), not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0 1), not a DOUBLE-FLOAT.The second argument is a (REAL 0 1), not a RATIONAL.

;     (* 2
;        (IF (<= LH.STATISTICS::P-HAT LH.STATISTICS::P)
;            (LH.STATISTICS:PHI LH.STATISTICS:Z)
;            (- 1 (LH.STATISTICS:PHI LH.STATISTICS:Z))))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.

;     (<= LH.STATISTICS::P-HAT LH.STATISTICS::P)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0 1), not a SINGLE-FLOAT.The second argument is a (REAL 0 1), not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0 1), not a DOUBLE-FLOAT.The second argument is a (REAL 0 1), not a RATIONAL.

;     (* 2 LH.STATISTICS::PROBABILITY-MORE-EXTREME)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.

;     (MIN (* 2 LH.STATISTICS::PROBABILITY-MORE-EXTREME) 1.0)
; 
; note: unable to open-code RATIONAL to FLOAT comparison due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::P-HAT :PROB)
;                                   (LH.STATISTICS::N :POSINT)
;                                   (LH.STATISTICS::P :PROB))
; --> LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   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.

;     (- 1 LH.STATISTICS::P)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::N LH.STATISTICS::P LH.STATISTICS::Q)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (> (* LH.STATISTICS::N LH.STATISTICS::P LH.STATISTICS::Q) 10)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       etc.

;     (- LH.STATISTICS::P-HAT LH.STATISTICS::P)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL -1 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL -1 1) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P LH.STATISTICS::Q)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/ (- LH.STATISTICS::P-HAT LH.STATISTICS::P)
;        (SQRT (/ (* LH.STATISTICS::P LH.STATISTICS::Q) LH.STATISTICS::N)))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL -1 1), not a SINGLE-FLOAT.
;       The second argument is a (FLOAT 0.0 1.0), not a SINGLE-FLOAT.
;       The result is a (VALUES FLOAT &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (REAL -1 1), not a DOUBLE-FLOAT.
;       The second argument is a (FLOAT 0.0 1.0), not a DOUBLE-FLOAT.
;       The result is a (VALUES FLOAT &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (<= LH.STATISTICS::P-HAT LH.STATISTICS::P)
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL 0 1), not a DOUBLE-FLOAT.
;       The second argument is a (REAL 0 1), not a DOUBLE-FLOAT.

;     (* 2
;        (IF (<= LH.STATISTICS::P-HAT LH.STATISTICS::P)
;            (LH.STATISTICS:PHI LH.STATISTICS:Z)
;            (- 1 (LH.STATISTICS:PHI LH.STATISTICS:Z))))
; 
; note: forced to do GENERIC-* (cost 30)
;       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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P-HAT LH.STATISTICS::N)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (ROUND (* LH.STATISTICS::P-HAT LH.STATISTICS::N))
; 
; note: forced to do full call
;       unable to do inline float truncate (cost 5) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &OPTIONAL).
;       unable to do inline float truncate (cost 5) because:
;       The first argument is a (REAL 0), not a DOUBLE-FLOAT.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &OPTIONAL).

;     (<= LH.STATISTICS::P-HAT LH.STATISTICS::P)
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL 0 1), not a DOUBLE-FLOAT.
;       The second argument is a (REAL 0 1), not a DOUBLE-FLOAT.

;     (* 2 LH.STATISTICS::PROBABILITY-MORE-EXTREME)
; 
; note: forced to do GENERIC-* (cost 30)
;       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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (MIN (* 2 LH.STATISTICS::PROBABILITY-MORE-EXTREME) 1.0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.

; in: DEFUN BINOMIAL-TEST-TWO-SAMPLE
;     (/
;      (+ (* LH.STATISTICS::P-HAT1 LH.STATISTICS::N1)
;         (* LH.STATISTICS::P-HAT2 LH.STATISTICS::N2))
;      (+ LH.STATISTICS::N1 LH.STATISTICS::N2))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a INTEGER.The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (ABS (- LH.STATISTICS::P-HAT1 LH.STATISTICS::P-HAT2))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL -1 1), not a RATIONAL.

;     (/ LH.STATISTICS::N1)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (RATIONAL (0) 1) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (/ LH.STATISTICS::N2)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (RATIONAL (0) 1) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (SQRT
;      (* LH.STATISTICS::P-HAT LH.STATISTICS::Q-HAT
;         (+ (/ LH.STATISTICS::N1) (/ LH.STATISTICS::N2))))
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (> (* LH.STATISTICS::N1 LH.STATISTICS::P-HAT LH.STATISTICS::Q-HAT) 5)
; 
; 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.

;     (> (* LH.STATISTICS::N2 LH.STATISTICS::P-HAT LH.STATISTICS::Q-HAT) 5)
; 
; 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.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::P-HAT1 :PROB)
;                                   (LH.STATISTICS::N1 :POSINT)
;                                   (LH.STATISTICS::P-HAT2 :PROB)
;                                   (LH.STATISTICS::N2 :POSINT))
; --> LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   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.

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

;     (* LH.STATISTICS::P-HAT1 LH.STATISTICS::N1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P-HAT2 LH.STATISTICS::N2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ (* LH.STATISTICS::P-HAT1 LH.STATISTICS::N1)
;        (* LH.STATISTICS::P-HAT2 LH.STATISTICS::N2))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::N1 LH.STATISTICS::N2)
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 1), not a FIXNUM.
;       The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- 1 LH.STATISTICS::P-HAT)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL * 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL * 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::P-HAT1 LH.STATISTICS::P-HAT2)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL -1 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL -1 1) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

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

;     (* 2 LH.STATISTICS::N1)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* 2 LH.STATISTICS::N2)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- (ABS (- LH.STATISTICS::P-HAT1 LH.STATISTICS::P-HAT2))
;        (+ (/ (* 2 LH.STATISTICS::N1)) (/ (* 2 LH.STATISTICS::N2))))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (RATIONAL (0) 1), not a FIXNUM.
;       The result is a (VALUES (OR (FLOAT -1.0 1.0) (RATIONAL -1 (1))) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (RATIONAL (0) 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (OR (FLOAT -1.0 1.0) (RATIONAL -1 (1))) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P-HAT LH.STATISTICS::Q-HAT
;        (+ (/ LH.STATISTICS::N1) (/ LH.STATISTICS::N2)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The second argument is a (REAL * 1), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL * 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ (/ LH.STATISTICS::N1) (/ LH.STATISTICS::N2))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL (0) 1), not a FIXNUM.
;       The second argument is a (RATIONAL (0) 1), not a FIXNUM.
;       The result is a (VALUES (RATIONAL (0) 2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (RATIONAL (0) 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (RATIONAL (0) 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (RATIONAL (0) 2) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P-HAT LH.STATISTICS::Q-HAT
;        (+ (/ LH.STATISTICS::N1) (/ LH.STATISTICS::N2)))
; 
; note: forced to do GENERIC-* (cost 30)
;       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) 2), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a (RATIONAL (0) 2), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/
;      (- (ABS (- LH.STATISTICS::P-HAT1 LH.STATISTICS::P-HAT2))
;         (+ (/ (* 2 LH.STATISTICS::N1)) (/ (* 2 LH.STATISTICS::N2))))
;      (SQRT
;       (* LH.STATISTICS::P-HAT LH.STATISTICS::Q-HAT
;          (+ (/ LH.STATISTICS::N1) (/ LH.STATISTICS::N2)))))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (OR (FLOAT -1.0 1.0) (RATIONAL -1 (1))), not a SINGLE-FLOAT.
;       The second argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR (FLOAT -1.0 1.0) (RATIONAL -1 (1))), not a DOUBLE-FLOAT.
;       The second argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (* LH.STATISTICS::N1 LH.STATISTICS::P-HAT LH.STATISTICS::Q-HAT)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The second argument is a (REAL * 1), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL * 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (> (* LH.STATISTICS::N1 LH.STATISTICS::P-HAT LH.STATISTICS::Q-HAT) 5)
; 
; 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.

;     (* LH.STATISTICS::N2 LH.STATISTICS::P-HAT LH.STATISTICS::Q-HAT)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The second argument is a (REAL * 1), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL * 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (> (* LH.STATISTICS::N2 LH.STATISTICS::P-HAT LH.STATISTICS::Q-HAT) 5)
; 
; 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.

;     (* LH.STATISTICS::P-HAT1 LH.STATISTICS::N1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- 1 (* LH.STATISTICS::P-HAT1 LH.STATISTICS::N1))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL * 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL * 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P-HAT2 LH.STATISTICS::N2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- 1 (* LH.STATISTICS::P-HAT2 LH.STATISTICS::N2))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL * 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL * 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN FISHER-EXACT-TEST
;     (AREF LH.STATISTICS::CONTINGENCY-TABLE 0 0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.

;     (AREF LH.STATISTICS::CONTINGENCY-TABLE 0 1)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.

;     (AREF LH.STATISTICS::CONTINGENCY-TABLE 1 0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.

;     (AREF LH.STATISTICS::CONTINGENCY-TABLE 1 1)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.

;     (MIN LH.STATISTICS::ROW-MARGIN1 LH.STATISTICS::ROW-MARGIN2
;          LH.STATISTICS::COLUMN-MARGIN1 LH.STATISTICS::COLUMN-MARGIN2)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.

;     (< LH.STATISTICS::ROW-MARGIN2 LH.STATISTICS::ROW-MARGIN1)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.

;     (< LH.STATISTICS::COLUMN-MARGIN2 LH.STATISTICS::COLUMN-MARGIN1)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.

;     (< LH.STATISTICS::ROW-MARGIN2 LH.STATISTICS::ROW-MARGIN1)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.

;     (< LH.STATISTICS::COLUMN-MARGIN2 LH.STATISTICS::COLUMN-MARGIN1)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.

;     (MIN LH.STATISTICS::ABOVE LH.STATISTICS::BELOW)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.

;     (* 2 (MIN LH.STATISTICS::ABOVE LH.STATISTICS::BELOW))
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.

;     (AREF LH.STATISTICS::CONTINGENCY-TABLE 0 0)
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.

;     (/
;      (* (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::A LH.STATISTICS::B))
;         (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::C LH.STATISTICS::D))
;         (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::A LH.STATISTICS::C))
;         (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::B LH.STATISTICS::D)))
;      (* (LH.STATISTICS::FACTORIAL LH.STATISTICS::N)
;         (LH.STATISTICS::FACTORIAL LH.STATISTICS::A)
;         (LH.STATISTICS::FACTORIAL LH.STATISTICS::B)
;         (LH.STATISTICS::FACTORIAL LH.STATISTICS::C)
;         (LH.STATISTICS::FACTORIAL LH.STATISTICS::D)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (AREF LH.STATISTICS::CONTINGENCY-TABLE 0 1)
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.

;     (AREF LH.STATISTICS::CONTINGENCY-TABLE 1 0)
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.

;     (AREF LH.STATISTICS::CONTINGENCY-TABLE 1 1)
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.

;     (+ LH.STATISTICS::A LH.STATISTICS::B)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::C LH.STATISTICS::D)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::A LH.STATISTICS::C)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::B LH.STATISTICS::D)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::A LH.STATISTICS::B LH.STATISTICS::C LH.STATISTICS::D)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (MIN LH.STATISTICS::ROW-MARGIN1 LH.STATISTICS::ROW-MARGIN2
;          LH.STATISTICS::COLUMN-MARGIN1 LH.STATISTICS::COLUMN-MARGIN2)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       etc.
; 
; 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 NUMBER, 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 NUMBER, not a DOUBLE-FLOAT.
;       etc.
; 
; 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 NUMBER, 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 NUMBER, not a DOUBLE-FLOAT.
;       etc.

;     (< LH.STATISTICS::ROW-MARGIN2 LH.STATISTICS::ROW-MARGIN1)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (< LH.STATISTICS::COLUMN-MARGIN2 LH.STATISTICS::COLUMN-MARGIN1)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (< LH.STATISTICS::ROW-MARGIN2 LH.STATISTICS::ROW-MARGIN1)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (< LH.STATISTICS::COLUMN-MARGIN2 LH.STATISTICS::COLUMN-MARGIN1)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (- LH.STATISTICS::ROW-MARGIN1 LH.STATISTICS::I)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::COLUMN-MARGIN1 LH.STATISTICS::I)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::TEST-A LH.STATISTICS::TEST-B LH.STATISTICS::TEST-C)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; 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 REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::N
;        (+ LH.STATISTICS::TEST-A LH.STATISTICS::TEST-B LH.STATISTICS::TEST-C))
; 
; 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 REAL, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::A LH.STATISTICS::B LH.STATISTICS::C LH.STATISTICS::D)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; 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 REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::A LH.STATISTICS::B)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::C LH.STATISTICS::D)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (* (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::A LH.STATISTICS::B))
;        (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::C LH.STATISTICS::D))
;        (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::A LH.STATISTICS::C))
;        (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::B LH.STATISTICS::D)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::A LH.STATISTICS::C)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::A LH.STATISTICS::B))
;        (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::C LH.STATISTICS::D))
;        (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::A LH.STATISTICS::C))
;        (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::B LH.STATISTICS::D)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::B LH.STATISTICS::D)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (* (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::A LH.STATISTICS::B))
;        (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::C LH.STATISTICS::D))
;        (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::A LH.STATISTICS::C))
;        (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::B LH.STATISTICS::D)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* (LH.STATISTICS::FACTORIAL LH.STATISTICS::N)
;        (LH.STATISTICS::FACTORIAL LH.STATISTICS::A)
;        (LH.STATISTICS::FACTORIAL LH.STATISTICS::B)
;        (LH.STATISTICS::FACTORIAL LH.STATISTICS::C)
;        (LH.STATISTICS::FACTORIAL LH.STATISTICS::D))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/
;      (* (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::A LH.STATISTICS::B))
;         (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::C LH.STATISTICS::D))
;         (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::A LH.STATISTICS::C))
;         (LH.STATISTICS::FACTORIAL (+ LH.STATISTICS::B LH.STATISTICS::D)))
;      (* (LH.STATISTICS::FACTORIAL LH.STATISTICS::N)
;         (LH.STATISTICS::FACTORIAL LH.STATISTICS::A)
;         (LH.STATISTICS::FACTORIAL LH.STATISTICS::B)
;         (LH.STATISTICS::FACTORIAL LH.STATISTICS::C)
;         (LH.STATISTICS::FACTORIAL LH.STATISTICS::D)))
; 
; 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 NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (MIN LH.STATISTICS::ABOVE LH.STATISTICS::BELOW)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       etc.

;     (* 2 (MIN LH.STATISTICS::ABOVE LH.STATISTICS::BELOW))
; 
; note: forced to do GENERIC-* (cost 30)
;       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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (FLOAT
;      (ECASE LH.STATISTICS::TAILS
;        ((:BOTH) (* 2 (MIN LH.STATISTICS::ABOVE LH.STATISTICS::BELOW)))
;        ((:POSITIVE) LH.STATISTICS::BELOW)
;        ((:NEGATIVE) LH.STATISTICS::ABOVE))
;      1.0d0)
; 
; 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).

;     (DEFUN LH.STATISTICS:FISHER-EXACT-TEST
;            (LH.STATISTICS::CONTINGENCY-TABLE &KEY (LH.STATISTICS::TAILS :BOTH))
;       "Fisher's exact test.  Gives a p value for a particular 2x2 contingency table"
;       (FLET ((LH.STATISTICS::TABLE-PROBABILITY
;                  (LH.STATISTICS::A LH.STATISTICS::B LH.STATISTICS::C
;                   LH.STATISTICS::D)
;                (LET #
;                  #)))
;         (LET ((LH.STATISTICS::A #)
;               (LH.STATISTICS::B #)
;               (LH.STATISTICS::C #)
;               (LH.STATISTICS::D #))
;           (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::A NUMBER)
;                                         (LH.STATISTICS::B NUMBER)
;                                         (LH.STATISTICS::C NUMBER)
;                                         (LH.STATISTICS::D NUMBER))
;           (LET* (# # # # # #)
;             (COND # # #)
;             (DOTIMES # #)
;             (LET #
;               #)))))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA LH.STATISTICS:FISHER-EXACT-TEST
;         (LH.STATISTICS::CONTINGENCY-TABLE &KEY (LH.STATISTICS::TAILS :BOTH))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       "Fisher's exact test.  Gives a p value for a particular 2x2 contingency table"
;       (BLOCK LH.STATISTICS:FISHER-EXACT-TEST
;         (FLET ((LH.STATISTICS::TABLE-PROBABILITY #
;                  #))
;           (LET (# # # #)
;             (LH.STATISTICS:TEST-VARIABLES # # # #)
;             (LET* #
;               #
;               #
;               #)))))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; in: DEFUN MCNEMARS-TEST
;     (/
;      (LH.STATISTICS:SQUARE
;       (-
;        (ABS
;         (- LH.STATISTICS::A-DISCORDANT-COUNT LH.STATISTICS::B-DISCORDANT-COUNT))
;        1))
;      LH.STATISTICS::N)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES RATIONAL &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (* 2
;        (LH.STATISTICS::BINOMIAL-LE-PROBABILITY LH.STATISTICS::N
;         LH.STATISTICS::A-DISCORDANT-COUNT 1/2))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.

;     (* 2
;        (LH.STATISTICS:BINOMIAL-GE-PROBABILITY LH.STATISTICS::N
;         LH.STATISTICS::A-DISCORDANT-COUNT 1/2))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::A-DISCORDANT-COUNT :POSINT)
;                                   (LH.STATISTICS::B-DISCORDANT-COUNT :POSINT))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   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.

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

;     (+ LH.STATISTICS::A-DISCORDANT-COUNT LH.STATISTICS::B-DISCORDANT-COUNT)
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 1), not a FIXNUM.
;       The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::A-DISCORDANT-COUNT LH.STATISTICS::B-DISCORDANT-COUNT)
; 
; note: forced to do GENERIC-- (cost 10)
;       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 1), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (ABS (- LH.STATISTICS::A-DISCORDANT-COUNT LH.STATISTICS::B-DISCORDANT-COUNT))
; 
; 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.
; 
; 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 &OPTIONAL).
;       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) &OPTIONAL).
;       etc.

;     (-
;      (ABS
;       (- LH.STATISTICS::A-DISCORDANT-COUNT LH.STATISTICS::B-DISCORDANT-COUNT))
;      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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::A-DISCORDANT-COUNT LH.STATISTICS::B-DISCORDANT-COUNT)
; 
; note: forced to do GENERIC-- (cost 10)
;       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 1), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (ABS (- LH.STATISTICS::A-DISCORDANT-COUNT LH.STATISTICS::B-DISCORDANT-COUNT))
; 
; 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.
; 
; 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 &OPTIONAL).
;       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) &OPTIONAL).
;       etc.

;     (-
;      (ABS
;       (- LH.STATISTICS::A-DISCORDANT-COUNT LH.STATISTICS::B-DISCORDANT-COUNT))
;      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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE
;      (-
;       (ABS
;        (- LH.STATISTICS::A-DISCORDANT-COUNT LH.STATISTICS::B-DISCORDANT-COUNT))
;       1))
; 
; note: forced to do GENERIC-* (cost 30)
;       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 -1), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER -1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- 1 (LH.STATISTICS:CHI-SQUARE-CDF LH.STATISTICS::X2 1))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (= LH.STATISTICS::A-DISCORDANT-COUNT LH.STATISTICS::B-DISCORDANT-COUNT)
; 
; note: forced to do %EQL/INTEGER2 (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 1), not a FIXNUM.

;     (< LH.STATISTICS::A-DISCORDANT-COUNT LH.STATISTICS::B-DISCORDANT-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 (INTEGER 1), not a FIXNUM.

; in: DEFUN POISSON-TEST-ONE-SAMPLE
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::OBSERVED :POSNUM)
;                                   (LH.STATISTICS::MU :POSNUM))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

; --> LET IF UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

;     (/ (LH.STATISTICS:SQUARE (- LH.STATISTICS::OBSERVED LH.STATISTICS::MU))
;        LH.STATISTICS::MU)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a INTEGER.The second argument is a (REAL (0)), not a INTEGER.The result is a (VALUES REAL &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (< LH.STATISTICS::OBSERVED LH.STATISTICS::MU)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL (0)), not a SINGLE-FLOAT.The second argument is a (REAL (0)), not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL (0)), not a DOUBLE-FLOAT.The second argument is a (REAL (0)), not a RATIONAL.

;     (* 2 LH.STATISTICS::PROBABILITY-MORE-EXTREME)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.

;     (MIN (* 2 LH.STATISTICS::PROBABILITY-MORE-EXTREME) 1.0)
; 
; note: unable to open-code RATIONAL to FLOAT comparison due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::OBSERVED :POSNUM)
;                                   (LH.STATISTICS::MU :POSNUM))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

; --> LET IF UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

;     (< LH.STATISTICS::OBSERVED LH.STATISTICS::MU)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The second argument is a (REAL (0)), not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       The second argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       etc.

;     (* 2 LH.STATISTICS::PROBABILITY-MORE-EXTREME)
; 
; note: forced to do GENERIC-* (cost 30)
;       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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (MIN (* 2 LH.STATISTICS::PROBABILITY-MORE-EXTREME) 1.0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.

;     (- LH.STATISTICS::OBSERVED LH.STATISTICS::MU)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The second argument is a (REAL (0)), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The second argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The second argument is a (REAL (0)), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The second argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE (- LH.STATISTICS::OBSERVED LH.STATISTICS::MU))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/ (LH.STATISTICS:SQUARE (- LH.STATISTICS::OBSERVED LH.STATISTICS::MU))
;        LH.STATISTICS::MU)
; 
; 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 (REAL (0)), not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (- 1 (LH.STATISTICS:CHI-SQUARE-CDF LH.STATISTICS::X-SQUARE 1))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN SIGN-TEST
;     (/ LH.STATISTICS::PLUS-COUNT LH.STATISTICS::N)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (RATIONAL (0)) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (* 2 LH.STATISTICS::AREA)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::PLUS-COUNT :POSINT)
;                                   (LH.STATISTICS::MINUS-COUNT :POSINT))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   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.

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

;     (+ LH.STATISTICS::PLUS-COUNT LH.STATISTICS::MINUS-COUNT)
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 1), not a FIXNUM.
;       The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::PLUS-COUNT LH.STATISTICS::MINUS-COUNT)
; 
; note: forced to do GENERIC-- (cost 10)
;       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 1), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (ABS (- LH.STATISTICS::PLUS-COUNT LH.STATISTICS::MINUS-COUNT))
; 
; 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.
; 
; 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 &OPTIONAL).
;       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) &OPTIONAL).
;       etc.

;     (1- (ABS (- LH.STATISTICS::PLUS-COUNT LH.STATISTICS::MINUS-COUNT)))
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (/ (1- (ABS (- LH.STATISTICS::PLUS-COUNT LH.STATISTICS::MINUS-COUNT)))
;        (SQRT LH.STATISTICS::N))
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (INTEGER 4611686018427387904), not a (SIGNED-BYTE 64).

; in: DEFUN SIGN-TEST-ON-SEQUENCES
;     (LENGTH LH.STATISTICS::SEQUENCE1)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS VECTOR SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

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

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::SEQUENCE1 :NUMSEQ)
;                                   (LH.STATISTICS::SEQUENCE2 :NUMSEQ)
;                                   ("Sequences must be of equal length" :TEST
;                                    (= (LENGTH LH.STATISTICS::SEQUENCE1)
;                                       (LENGTH LH.STATISTICS::SEQUENCE2))))
; --> LET UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

;     (MAP 'LIST #'- LH.STATISTICS::SEQUENCE1 LH.STATISTICS::SEQUENCE2)
; 
; note: unable to open code because: can't determine sequence argument type

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::SEQUENCE1 :NUMSEQ)
;                                   (LH.STATISTICS::SEQUENCE2 :NUMSEQ)
;                                   ("Sequences must be of equal length" :TEST
;                                    (= (LENGTH LH.STATISTICS::SEQUENCE1)
;                                       (LENGTH LH.STATISTICS::SEQUENCE2))))
; --> LET IF LET UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFUN WILCOXON-SIGNED-RANK-TEST
;     (ABS LH.STATISTICS::DIF)
; 
; 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.

;     (= (SECOND LH.STATISTICS::ENTRY) LH.STATISTICS::DIRECTION)
; 
; 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.

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

;     (/ (* LH.STATISTICS::N (1+ LH.STATISTICS::N)) 4)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (RATIONAL 0 77371252455331869134684160) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (/
;      (REDUCE #'+
;              (MAPCAR #'(LAMBDA (LH.STATISTICS::TI) (- # LH.STATISTICS::TI))
;                      LH.STATISTICS::TIES))
;      48)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.

;     (/ (* LH.STATISTICS::N (1+ LH.STATISTICS::N) (1+ (* 2 LH.STATISTICS::N))) 24)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (RATIONAL 0 453709822561212598991605142508441436160) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (ABS (- LH.STATISTICS::R1 LH.STATISTICS::EXPECTED-R1))
; 
; 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.

;     (SQRT LH.STATISTICS::VAR-R1)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-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 (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (/ (+ FIRST LAST) 2)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (RATIONAL 0 17592186044414) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (* LH.STATISTICS::N (1+ LH.STATISTICS::N))
; 
; note: forced to do */UNSIGNED=>INTEGER (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The result is a (VALUES (MOD 309485009821327476538736641) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The result is a (VALUES (MOD 309485009821327476538736641) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::N (1+ LH.STATISTICS::N) (1+ (* 2 LH.STATISTICS::N)))
; 
; note: forced to do */UNSIGNED=>INTEGER (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The result is a (VALUES (MOD 309485009821327476538736641) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The result is a (VALUES (MOD 309485009821327476538736641) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD 309485009821327476538736641), not a FIXNUM.
;       The result is a (VALUES (MOD 10889035741469102375798523420202594467841) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD 309485009821327476538736641), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (MOD 10889035741469102375798523420202594467841) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (-
;      (/ (* LH.STATISTICS::N (1+ LH.STATISTICS::N) (1+ (* 2 LH.STATISTICS::N)))
;         24)
;      LH.STATISTICS::TIES-FACTOR)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL 0 453709822561212598991605142508441436160), not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (RATIONAL 0 453709822561212598991605142508441436160), not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::R1 LH.STATISTICS::EXPECTED-R1)
; 
; 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 (RATIONAL 0 77371252455331869134684160), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (RATIONAL 0 77371252455331869134684160), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

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

;     (/ (- (ABS (- LH.STATISTICS::R1 LH.STATISTICS::EXPECTED-R1)) 1/2)
;        (SQRT LH.STATISTICS::VAR-R1))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL -1/2), not a SINGLE-FLOAT.
;       The second argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (REAL -1/2), not a DOUBLE-FLOAT.
;       The second argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (* LH.STATISTICS::TI LH.STATISTICS::TI LH.STATISTICS::TI)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- (* LH.STATISTICS::TI LH.STATISTICS::TI LH.STATISTICS::TI)
;        LH.STATISTICS::TI)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (POSITION LH.STATISTICS::VALUE LH.STATISTICS::SORTED-LIST :KEY #'FIRST)
; 
; note: forced to do IF-EQL (cost 15)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       etc.

;     (POSITION LH.STATISTICS::VALUE LH.STATISTICS::SORTED-LIST :KEY #'FIRST
;               :FROM-END T)
; 
; note: forced to do IF-EQL (cost 15)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       etc.

;     (FIND LH.STATISTICS::VALUE LH.STATISTICS::SORTED-LIST :KEY #'FIRST)
; 
; note: forced to do IF-EQL (cost 15)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       etc.

;     (1+ (/ (+ FIRST LAST) 2))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (RATIONAL 0 17592186044414), not a FIXNUM.
;       The result is a (VALUES (RATIONAL 1 17592186044415) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL 0 17592186044414), not a FIXNUM.
;       The result is a (VALUES (RATIONAL 1 17592186044415) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (ABS LH.STATISTICS::DIF)
; 
; note: forced to do full call
;       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 &OPTIONAL).
;       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 &OPTIONAL).

; in: DEFUN WILCOXON-SIGNED-RANK-TEST-ON-SEQUENCES
;     (LENGTH LH.STATISTICS::SEQUENCE1)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS VECTOR SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

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

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::SEQUENCE1 :NUMSEQ)
;                                   (LH.STATISTICS::SEQUENCE2 :NUMSEQ)
;                                   ("Sequences must be of equal length" :TEST
;                                    (= (LENGTH LH.STATISTICS::SEQUENCE1)
;                                       (LENGTH LH.STATISTICS::SEQUENCE2))))
; --> LET UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

;     (MAP 'LIST #'- LH.STATISTICS::SEQUENCE1 LH.STATISTICS::SEQUENCE2)
; 
; note: unable to open code because: can't determine sequence argument type

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::SEQUENCE1 :NUMSEQ)
;                                   (LH.STATISTICS::SEQUENCE2 :NUMSEQ)
;                                   ("Sequences must be of equal length" :TEST
;                                    (= (LENGTH LH.STATISTICS::SEQUENCE1)
;                                       (LENGTH LH.STATISTICS::SEQUENCE2))))
; --> LET IF LET UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFUN CHI-SQUARE-TEST-RXC
;     (ARRAY-DIMENSION LH.STATISTICS::CONTINGENCY-TABLE 0)
; 
; note: unable to optimize because: The array dimensions are unknown; must call ARRAY-DIMENSION at runtime.

;     (ARRAY-DIMENSION LH.STATISTICS::CONTINGENCY-TABLE 1)
; 
; note: unable to optimize because: The array dimensions are unknown; must call ARRAY-DIMENSION at runtime.

;     (/ (* LH.STATISTICS::ROWS LH.STATISTICS::COLUMNS) 5)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (RATIONAL 0 61897001964261976870538445) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (AREF LH.STATISTICS::CONTINGENCY-TABLE LH.STATISTICS::I LH.STATISTICS::J)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.

;     (INCF (SVREF LH.STATISTICS::ROW-MARGINALS LH.STATISTICS::I)
;           LH.STATISTICS::CELL)
; ==>
;   (+ LH.STATISTICS::CELL (SVREF #:ROW-MARGINALS7 #:I8))
; 
; 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 T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (INCF (SVREF LH.STATISTICS::COLUMN-MARGINALS LH.STATISTICS::J)
;           LH.STATISTICS::CELL)
; ==>
;   (+ LH.STATISTICS::CELL (SVREF #:COLUMN-MARGINALS13 #:J14))
; 
; 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 T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (INCF LH.STATISTICS::TOTAL LH.STATISTICS::CELL)
; --> THE 
; ==>
;   (+ LH.STATISTICS::CELL LH.STATISTICS::TOTAL)
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (* (AREF LH.STATISTICS::ROW-MARGINALS LH.STATISTICS::I)
;        (AREF LH.STATISTICS::COLUMN-MARGINALS LH.STATISTICS::J))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/
;      (* (AREF LH.STATISTICS::ROW-MARGINALS LH.STATISTICS::I)
;         (AREF LH.STATISTICS::COLUMN-MARGINALS LH.STATISTICS::J))
;      LH.STATISTICS::TOTAL)
; 
; 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 (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (INCF LH.STATISTICS::EXPECTED-LT-1)
; --> THE 
; ==>
;   (+ 1 LH.STATISTICS::EXPECTED-LT-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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (INCF LH.STATISTICS::EXPECTED-LT-5)
; --> THE 
; ==>
;   (+ 1 LH.STATISTICS::EXPECTED-LT-5)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::ROWS LH.STATISTICS::COLUMNS)
; 
; note: forced to do */UNSIGNED=>INTEGER (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The result is a (VALUES (MOD 309485009821309884352692226) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The result is a (VALUES (MOD 309485009821309884352692226) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (> LH.STATISTICS::EXPECTED-LT-5
;        (/ (* LH.STATISTICS::ROWS LH.STATISTICS::COLUMNS) 5))
; 
; 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 (RATIONAL 0 61897001964261976870538445), not a FIXNUM.

;     (- (AREF LH.STATISTICS::CONTINGENCY-TABLE LH.STATISTICS::I LH.STATISTICS::J)
;        (AREF LH.STATISTICS::EXPECTED-VALUES LH.STATISTICS::I LH.STATISTICS::J))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).

;     (LH.STATISTICS:SQUARE
;      (- (AREF LH.STATISTICS::CONTINGENCY-TABLE LH.STATISTICS::I LH.STATISTICS::J)
;         (AREF LH.STATISTICS::EXPECTED-VALUES LH.STATISTICS::I LH.STATISTICS::J)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The second argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The second argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (/
;      (LH.STATISTICS:SQUARE
;       (-
;        (AREF LH.STATISTICS::CONTINGENCY-TABLE LH.STATISTICS::I LH.STATISTICS::J)
;        (AREF LH.STATISTICS::EXPECTED-VALUES LH.STATISTICS::I LH.STATISTICS::J)))
;      (AREF LH.STATISTICS::EXPECTED-VALUES LH.STATISTICS::I LH.STATISTICS::J))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).

;     (INCF LH.STATISTICS::X2
;           (/
;            (LH.STATISTICS:SQUARE
;             (-
;              (AREF LH.STATISTICS::CONTINGENCY-TABLE LH.STATISTICS::I
;                    LH.STATISTICS::J)
;              (AREF LH.STATISTICS::EXPECTED-VALUES LH.STATISTICS::I
;                    LH.STATISTICS::J)))
;            (AREF LH.STATISTICS::EXPECTED-VALUES LH.STATISTICS::I
;                  LH.STATISTICS::J)))
; --> THE 
; ==>
;   (+
;    (/
;     (LH.STATISTICS:SQUARE
;      (-
;       (AREF LH.STATISTICS::CONTINGENCY-TABLE LH.STATISTICS::I LH.STATISTICS::J)
;       (AREF LH.STATISTICS::EXPECTED-VALUES LH.STATISTICS::I LH.STATISTICS::J)))
;     (AREF LH.STATISTICS::EXPECTED-VALUES LH.STATISTICS::I LH.STATISTICS::J))
;    LH.STATISTICS::X2)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The second argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (* (1- LH.STATISTICS::ROWS) (1- LH.STATISTICS::COLUMNS))
; 
; note: forced to do */SIGNED=>INTEGER (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The result is a (VALUES (INTEGER -17592186044414 309485009821274699980603396) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER -1 17592186044414), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -1 17592186044414), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER -17592186044414 309485009821274699980603396) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- 1
;        (LH.STATISTICS:CHI-SQUARE-CDF LH.STATISTICS::X2
;         (* (1- LH.STATISTICS::ROWS) (1- LH.STATISTICS::COLUMNS))))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN CHI-SQUARE-TEST-FOR-TREND
;     (LENGTH LH.STATISTICS::ROW1-COUNTS)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS VECTOR SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

;     (LENGTH LH.STATISTICS::ROW2-COUNTS)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS VECTOR SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

;     (LENGTH LH.STATISTICS::ROW1-COUNTS)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::ROW1-COUNTS :POSINTSEQ)
;                                   (LH.STATISTICS::ROW2-COUNTS :POSINTSEQ)
;                                   (LH.STATISTICS::SCORES :NUMSEQ)
;                                   ("Sequences must be of equal length" :TEST
;                                    (= (LENGTH LH.STATISTICS::ROW1-COUNTS)
;                                       (LENGTH LH.STATISTICS::ROW2-COUNTS))))
; --> LET UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

; --> LET IF LET UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

;     (MAP 'LIST #'+ LH.STATISTICS::ROW1-COUNTS LH.STATISTICS::ROW2-COUNTS)
; 
; note: unable to open code because: can't determine sequence argument type

;     (MAP 'LIST #'/ LH.STATISTICS::ROW1-COUNTS LH.STATISTICS::NS)
; 
; note: unable to open code because: can't determine sequence argument type

;     (/ (REDUCE #'+ LH.STATISTICS::ROW1-COUNTS) LH.STATISTICS::N)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (/
;      (LH.STATISTICS:SQUARE
;       (REDUCE #'+ (MAPCAR (LAMBDA # #) LH.STATISTICS::NS LH.STATISTICS::SCORES)))
;      LH.STATISTICS::N)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (/ (LH.STATISTICS:SQUARE LH.STATISTICS::A) LH.STATISTICS::B)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.The result is a (VALUES REAL &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (< (* LH.STATISTICS::P-BAR LH.STATISTICS::Q-BAR LH.STATISTICS::N) 5)
; 
; 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.

;     (< LH.STATISTICS::A 0)
; 
; 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.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::ROW1-COUNTS :POSINTSEQ)
;                                   (LH.STATISTICS::ROW2-COUNTS :POSINTSEQ)
;                                   (LH.STATISTICS::SCORES :NUMSEQ)
;                                   ("Sequences must be of equal length" :TEST
;                                    (= (LENGTH LH.STATISTICS::ROW1-COUNTS)
;                                       (LENGTH LH.STATISTICS::ROW2-COUNTS))))
; --> LET IF LET IF LET UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

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

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

;     (/ (REDUCE #'+ LH.STATISTICS::ROW1-COUNTS) LH.STATISTICS::N)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) 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 &OPTIONAL).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a T, 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) &OPTIONAL).
;       etc.

;     (- 1 LH.STATISTICS::P-BAR)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::P-HAT LH.STATISTICS::P-BAR)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) 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 &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::NI (- LH.STATISTICS::P-HAT LH.STATISTICS::P-BAR)
;        (- LH.STATISTICS::S LH.STATISTICS::S-BAR))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::S LH.STATISTICS::S-BAR)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) 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 &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::NI (- LH.STATISTICS::P-HAT LH.STATISTICS::P-BAR)
;        (- LH.STATISTICS::S LH.STATISTICS::S-BAR))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P-BAR LH.STATISTICS::Q-BAR
;        (-
;         (REDUCE #'+
;                 (MAPCAR (LAMBDA # #) LH.STATISTICS::NS LH.STATISTICS::SCORES))
;         (/ (LH.STATISTICS:SQUARE (REDUCE #'+ #)) LH.STATISTICS::N)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE LH.STATISTICS::S)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::NI (LH.STATISTICS:SQUARE LH.STATISTICS::S))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::NI LH.STATISTICS::S)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE
;      (REDUCE #'+
;              (MAPCAR
;               (LAMBDA (LH.STATISTICS::NI LH.STATISTICS::S)
;                 (* LH.STATISTICS::NI LH.STATISTICS::S))
;               LH.STATISTICS::NS LH.STATISTICS::SCORES)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/
;      (LH.STATISTICS:SQUARE
;       (REDUCE #'+ (MAPCAR (LAMBDA # #) LH.STATISTICS::NS LH.STATISTICS::SCORES)))
;      LH.STATISTICS::N)
; 
; 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 NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (-
;      (REDUCE #'+
;              (MAPCAR
;               (LAMBDA (LH.STATISTICS::NI LH.STATISTICS::S)
;                 (* LH.STATISTICS::NI #))
;               LH.STATISTICS::NS LH.STATISTICS::SCORES))
;      (/
;       (LH.STATISTICS:SQUARE
;        (REDUCE #'+ (MAPCAR # LH.STATISTICS::NS LH.STATISTICS::SCORES)))
;       LH.STATISTICS::N))
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) 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 &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P-BAR LH.STATISTICS::Q-BAR
;        (-
;         (REDUCE #'+
;                 (MAPCAR (LAMBDA # #) LH.STATISTICS::NS LH.STATISTICS::SCORES))
;         (/ (LH.STATISTICS:SQUARE (REDUCE #'+ #)) LH.STATISTICS::N)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE LH.STATISTICS::A)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/ (LH.STATISTICS:SQUARE LH.STATISTICS::A) LH.STATISTICS::B)
; 
; 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 NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (FLOAT LH.STATISTICS::X2)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a RATIONAL, not a (SIGNED-BYTE 64).

;     (- 1 (LH.STATISTICS:CHI-SQUARE-CDF (FLOAT LH.STATISTICS::X2) 1))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P-BAR LH.STATISTICS::Q-BAR LH.STATISTICS::N)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (< (* LH.STATISTICS::P-BAR LH.STATISTICS::Q-BAR LH.STATISTICS::N) 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

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

; in: DEFUN T-TEST-ONE-SAMPLE-SSE
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::MU NUMBER)
;                                   (LH.STATISTICS::MU-NULL NUMBER)
;                                   (LH.STATISTICS:VARIANCE :POSNUM)
;                                   (LH.STATISTICS::ALPHA :PROB)
;                                   (LH.STATISTICS::1-BETA :PROB))
; --> LET IF LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

;     (/ LH.STATISTICS::ALPHA 2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1/2) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::MU NUMBER)
;                                   (LH.STATISTICS::MU-NULL NUMBER)
;                                   (LH.STATISTICS:VARIANCE :POSNUM)
;                                   (LH.STATISTICS::ALPHA :PROB)
;                                   (LH.STATISTICS::1-BETA :PROB))
; --> LET IF LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

;     (- 1
;        (IF (EQL LH.STATISTICS::TAILS :BOTH)
;            (/ LH.STATISTICS::ALPHA 2)
;            LH.STATISTICS::ALPHA))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::Z-BETA LH.STATISTICS::Z-ALPHA)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE (+ LH.STATISTICS::Z-BETA LH.STATISTICS::Z-ALPHA))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (* LH.STATISTICS:VARIANCE
;        (LH.STATISTICS:SQUARE (+ LH.STATISTICS::Z-BETA LH.STATISTICS::Z-ALPHA)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (- LH.STATISTICS::MU-NULL LH.STATISTICS::MU)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE (- LH.STATISTICS::MU-NULL LH.STATISTICS::MU))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/
;      (* LH.STATISTICS:VARIANCE
;         (LH.STATISTICS:SQUARE (+ LH.STATISTICS::Z-BETA LH.STATISTICS::Z-ALPHA)))
;      (LH.STATISTICS:SQUARE (- LH.STATISTICS::MU-NULL LH.STATISTICS::MU)))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

; in: DEFUN T-TEST-TWO-SAMPLE-SSE
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::MU1 NUMBER)
;                                   (LH.STATISTICS::VARIANCE1 :POSNUM)
;                                   (LH.STATISTICS::MU2 NUMBER)
;                                   (LH.STATISTICS::VARIANCE2 :POSNUM)
;                                   (LH.STATISTICS::SAMPLE-RATIO :POSNUM)
;                                   (LH.STATISTICS::ALPHA :PROB)
;                                   (LH.STATISTICS::1-BETA :PROB))
; --> LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

; --> LET IF LET IF LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

; --> LET IF LET IF LET IF LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

;     (/ LH.STATISTICS::ALPHA 2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1/2) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1/2) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.

;     (/ LH.STATISTICS::VARIANCE2 LH.STATISTICS::SAMPLE-RATIO)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL (0)), not a INTEGER.The second argument is a (REAL (0)), not a INTEGER.The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::MU1 NUMBER)
;                                   (LH.STATISTICS::VARIANCE1 :POSNUM)
;                                   (LH.STATISTICS::MU2 NUMBER)
;                                   (LH.STATISTICS::VARIANCE2 :POSNUM)
;                                   (LH.STATISTICS::SAMPLE-RATIO :POSNUM)
;                                   (LH.STATISTICS::ALPHA :PROB)
;                                   (LH.STATISTICS::1-BETA :PROB))
; --> LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

; --> LET IF LET IF LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

; --> LET IF LET IF LET IF LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

;     (- LH.STATISTICS::MU1 LH.STATISTICS::MU2)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE (- LH.STATISTICS::MU1 LH.STATISTICS::MU2))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- 1
;        (IF (EQL LH.STATISTICS::TAILS :BOTH)
;            (/ LH.STATISTICS::ALPHA 2)
;            LH.STATISTICS::ALPHA))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ (LH.STATISTICS:Z LH.STATISTICS::1-BETA)
;        (LH.STATISTICS:Z
;         (- 1
;            (IF (EQL LH.STATISTICS::TAILS :BOTH)
;                (/ LH.STATISTICS::ALPHA 2)
;                LH.STATISTICS::ALPHA))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (- 1
;        (IF (EQL LH.STATISTICS::TAILS :BOTH)
;            (/ LH.STATISTICS::ALPHA 2)
;            LH.STATISTICS::ALPHA))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ (LH.STATISTICS:Z LH.STATISTICS::1-BETA)
;        (LH.STATISTICS:Z
;         (- 1
;            (IF (EQL LH.STATISTICS::TAILS :BOTH)
;                (/ LH.STATISTICS::ALPHA 2)
;                LH.STATISTICS::ALPHA))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE
;      (+ (LH.STATISTICS:Z LH.STATISTICS::1-BETA)
;         (LH.STATISTICS:Z
;          (- 1
;             (IF #
;                 #
;                 LH.STATISTICS::ALPHA)))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (/ LH.STATISTICS::VARIANCE2 LH.STATISTICS::SAMPLE-RATIO)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The second argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       The second argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (+ LH.STATISTICS::VARIANCE1
;        (/ LH.STATISTICS::VARIANCE2 LH.STATISTICS::SAMPLE-RATIO))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (OR (FLOAT 0.0) (RATIONAL (0))) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR (FLOAT 0.0) (RATIONAL (0))) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (*
;      (+ LH.STATISTICS::VARIANCE1
;         (/ LH.STATISTICS::VARIANCE2 LH.STATISTICS::SAMPLE-RATIO))
;      LH.STATISTICS::Z-TERM)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (FLOAT 0.0) (RATIONAL (0))), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (FLOAT 0.0) (RATIONAL (0))), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (/
;      (*
;       (+ LH.STATISTICS::VARIANCE1
;          (/ LH.STATISTICS::VARIANCE2 LH.STATISTICS::SAMPLE-RATIO))
;       LH.STATISTICS::Z-TERM)
;      LH.STATISTICS::DELTA2)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* LH.STATISTICS::SAMPLE-RATIO LH.STATISTICS::N1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN T-TEST-PAIRED-SSE
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::DIFFERENCE-MU NUMBER)
;                                   (LH.STATISTICS::DIFFERENCE-VARIANCE :POSNUM)
;                                   (LH.STATISTICS::ALPHA :PROB)
;                                   (LH.STATISTICS::1-BETA :PROB))
; --> LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

;     (* 2 LH.STATISTICS::DIFFERENCE-VARIANCE
;        (LH.STATISTICS:SQUARE
;         (+ (LH.STATISTICS:Z LH.STATISTICS::1-BETA) (LH.STATISTICS:Z (- 1 #)))))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL (0)), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL (0)), not a DOUBLE-FLOAT.
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a (REAL (0)), not a INTEGER.

;     (/ LH.STATISTICS::ALPHA 2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1/2) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1/2) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::DIFFERENCE-MU NUMBER)
;                                   (LH.STATISTICS::DIFFERENCE-VARIANCE :POSNUM)
;                                   (LH.STATISTICS::ALPHA :PROB)
;                                   (LH.STATISTICS::1-BETA :PROB))
; --> LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

;     (* 2 LH.STATISTICS::DIFFERENCE-VARIANCE
;        (LH.STATISTICS:SQUARE
;         (+ (LH.STATISTICS:Z LH.STATISTICS::1-BETA) (LH.STATISTICS:Z (- 1 #)))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The result is a (VALUES (OR (FLOAT 0.0) (RATIONAL (0))) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The result is a (VALUES (OR (FLOAT 0.0) (RATIONAL (0))) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- 1
;        (IF (EQL LH.STATISTICS::TAILS :BOTH)
;            (/ LH.STATISTICS::ALPHA 2)
;            LH.STATISTICS::ALPHA))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ (LH.STATISTICS:Z LH.STATISTICS::1-BETA)
;        (LH.STATISTICS:Z
;         (- 1
;            (IF (EQL LH.STATISTICS::TAILS :BOTH)
;                (/ LH.STATISTICS::ALPHA 2)
;                LH.STATISTICS::ALPHA))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (- 1
;        (IF (EQL LH.STATISTICS::TAILS :BOTH)
;            (/ LH.STATISTICS::ALPHA 2)
;            LH.STATISTICS::ALPHA))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ (LH.STATISTICS:Z LH.STATISTICS::1-BETA)
;        (LH.STATISTICS:Z
;         (- 1
;            (IF (EQL LH.STATISTICS::TAILS :BOTH)
;                (/ LH.STATISTICS::ALPHA 2)
;                LH.STATISTICS::ALPHA))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE
;      (+ (LH.STATISTICS:Z LH.STATISTICS::1-BETA)
;         (LH.STATISTICS:Z
;          (- 1
;             (IF #
;                 #
;                 LH.STATISTICS::ALPHA)))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (* 2 LH.STATISTICS::DIFFERENCE-VARIANCE
;        (LH.STATISTICS:SQUARE
;         (+ (LH.STATISTICS:Z LH.STATISTICS::1-BETA) (LH.STATISTICS:Z (- 1 #)))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (FLOAT 0.0) (RATIONAL (0))), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (FLOAT 0.0) (RATIONAL (0))), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (LH.STATISTICS:SQUARE LH.STATISTICS::DIFFERENCE-MU)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/
;      (* 2 LH.STATISTICS::DIFFERENCE-VARIANCE
;         (LH.STATISTICS:SQUARE
;          (+ (LH.STATISTICS:Z LH.STATISTICS::1-BETA) (LH.STATISTICS:Z #))))
;      (LH.STATISTICS:SQUARE LH.STATISTICS::DIFFERENCE-MU))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

; in: DEFUN BINOMIAL-TEST-ONE-SAMPLE-SSE
;     (/ LH.STATISTICS::ALPHA 2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1/2) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.

;     (/ (* LH.STATISTICS::P-ESTIMATED LH.STATISTICS::Q-ESTIMATED)
;        (* LH.STATISTICS::P-NULL LH.STATISTICS::Q-NULL))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The second argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (SQRT
;      (/ (* LH.STATISTICS::P-ESTIMATED LH.STATISTICS::Q-ESTIMATED)
;         (* LH.STATISTICS::P-NULL LH.STATISTICS::Q-NULL)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a DOUBLE-FLOAT.

;     (/ LH.STATISTICS::ALPHA 2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1/2) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.

;     (/ (* LH.STATISTICS::P-ESTIMATED LH.STATISTICS::Q-ESTIMATED)
;        (* LH.STATISTICS::P-NULL LH.STATISTICS::Q-NULL))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The second argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (SQRT
;      (/ (* LH.STATISTICS::P-ESTIMATED LH.STATISTICS::Q-ESTIMATED)
;         (* LH.STATISTICS::P-NULL LH.STATISTICS::Q-NULL)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a DOUBLE-FLOAT.

;     (- 1 LH.STATISTICS::P-NULL)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- 1 LH.STATISTICS::P-ESTIMATED)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P-NULL LH.STATISTICS::Q-NULL
;        (LH.STATISTICS:SQUARE
;         (+ (LH.STATISTICS:Z (- 1 #))
;            (* (LH.STATISTICS:Z LH.STATISTICS::1-BETA) (SQRT #)))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- 1
;        (IF (EQL LH.STATISTICS::TAILS :BOTH)
;            (/ LH.STATISTICS::ALPHA 2)
;            LH.STATISTICS::ALPHA))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P-ESTIMATED LH.STATISTICS::Q-ESTIMATED)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P-NULL LH.STATISTICS::Q-NULL)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/ (* LH.STATISTICS::P-ESTIMATED LH.STATISTICS::Q-ESTIMATED)
;        (* LH.STATISTICS::P-NULL LH.STATISTICS::Q-NULL))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (REAL 0 1), not a DOUBLE-FLOAT.
;       The second argument is a (REAL 0 1), not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (* (LH.STATISTICS:Z LH.STATISTICS::1-BETA)
;        (SQRT
;         (/ (* LH.STATISTICS::P-ESTIMATED LH.STATISTICS::Q-ESTIMATED)
;            (* LH.STATISTICS::P-NULL LH.STATISTICS::Q-NULL))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (FLOAT 0.0), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (FLOAT 0.0), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (+
;      (LH.STATISTICS:Z
;       (- 1
;          (IF (EQL LH.STATISTICS::TAILS :BOTH)
;              (/ LH.STATISTICS::ALPHA 2)
;              LH.STATISTICS::ALPHA)))
;      (* (LH.STATISTICS:Z LH.STATISTICS::1-BETA)
;         (SQRT
;          (/ (* LH.STATISTICS::P-ESTIMATED LH.STATISTICS::Q-ESTIMATED)
;             (* LH.STATISTICS::P-NULL LH.STATISTICS::Q-NULL)))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (- 1
;        (IF (EQL LH.STATISTICS::TAILS :BOTH)
;            (/ LH.STATISTICS::ALPHA 2)
;            LH.STATISTICS::ALPHA))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P-ESTIMATED LH.STATISTICS::Q-ESTIMATED)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P-NULL LH.STATISTICS::Q-NULL)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/ (* LH.STATISTICS::P-ESTIMATED LH.STATISTICS::Q-ESTIMATED)
;        (* LH.STATISTICS::P-NULL LH.STATISTICS::Q-NULL))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (REAL 0 1), not a DOUBLE-FLOAT.
;       The second argument is a (REAL 0 1), not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (* (LH.STATISTICS:Z LH.STATISTICS::1-BETA)
;        (SQRT
;         (/ (* LH.STATISTICS::P-ESTIMATED LH.STATISTICS::Q-ESTIMATED)
;            (* LH.STATISTICS::P-NULL LH.STATISTICS::Q-NULL))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (FLOAT 0.0), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (FLOAT 0.0), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (+
;      (LH.STATISTICS:Z
;       (- 1
;          (IF (EQL LH.STATISTICS::TAILS :BOTH)
;              (/ LH.STATISTICS::ALPHA 2)
;              LH.STATISTICS::ALPHA)))
;      (* (LH.STATISTICS:Z LH.STATISTICS::1-BETA)
;         (SQRT
;          (/ (* LH.STATISTICS::P-ESTIMATED LH.STATISTICS::Q-ESTIMATED)
;             (* LH.STATISTICS::P-NULL LH.STATISTICS::Q-NULL)))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE
;      (+
;       (LH.STATISTICS:Z
;        (- 1
;           (IF #
;               #
;               LH.STATISTICS::ALPHA)))
;       (* (LH.STATISTICS:Z LH.STATISTICS::1-BETA) (SQRT (/ # #)))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P-NULL LH.STATISTICS::Q-NULL
;        (LH.STATISTICS:SQUARE
;         (+ (LH.STATISTICS:Z (- 1 #))
;            (* (LH.STATISTICS:Z LH.STATISTICS::1-BETA) (SQRT #)))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (REAL 0 1), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (REAL 0 1), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (- LH.STATISTICS::P-ESTIMATED LH.STATISTICS::P-NULL)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL -1 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL -1 1) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL -1 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL -1 1) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE (- LH.STATISTICS::P-ESTIMATED LH.STATISTICS::P-NULL))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL -1 1), not a FIXNUM.
;       The second argument is a (REAL -1 1), not a FIXNUM.
;       The result is a (VALUES (REAL -1 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL -1 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL -1 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL -1 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/
;      (* LH.STATISTICS::P-NULL LH.STATISTICS::Q-NULL
;         (LH.STATISTICS:SQUARE (+ (LH.STATISTICS:Z #) (* # #))))
;      (LH.STATISTICS:SQUARE (- LH.STATISTICS::P-ESTIMATED LH.STATISTICS::P-NULL)))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (REAL -1 1), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (REAL -1 1), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

; in: DEFUN BINOMIAL-TEST-TWO-SAMPLE-SSE
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::P1 :PROB)
;                                   (LH.STATISTICS::P2 :PROB)
;                                   (LH.STATISTICS::ALPHA :PROB)
;                                   (LH.STATISTICS::1-BETA :PROB)
;                                   (LH.STATISTICS::SAMPLE-RATIO :POSNUM))
; --> LET IF LET IF LET IF LET IF UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

;     (ABS (- LH.STATISTICS::P1 LH.STATISTICS::P2))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL -1 1), not a RATIONAL.

;     (/ (+ LH.STATISTICS::P1 (* LH.STATISTICS::SAMPLE-RATIO LH.STATISTICS::P2))
;        (1+ LH.STATISTICS::SAMPLE-RATIO))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a INTEGER.The second argument is a (OR (FLOAT 1.0) (RATIONAL (1))), not a INTEGER.The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (/ LH.STATISTICS::ALPHA 2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1/2) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.

;     (/ LH.STATISTICS::SAMPLE-RATIO)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (REAL (0)), not a INTEGER.The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (SQRT
;      (* LH.STATISTICS::P-BAR LH.STATISTICS::Q-BAR
;         (1+ (/ LH.STATISTICS::SAMPLE-RATIO))))
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (/ (* LH.STATISTICS::P2 LH.STATISTICS::Q2) LH.STATISTICS::SAMPLE-RATIO)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The second argument is a (REAL (0)), not a INTEGER.The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (SQRT
;      (+ (* LH.STATISTICS::P1 LH.STATISTICS::Q1)
;         (/ (* LH.STATISTICS::P2 LH.STATISTICS::Q2) LH.STATISTICS::SAMPLE-RATIO)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a DOUBLE-FLOAT.

;     (/ LH.STATISTICS::SAMPLE-RATIO)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (REAL (0)), not a INTEGER.The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (SQRT
;      (* LH.STATISTICS::P-BAR LH.STATISTICS::Q-BAR
;         (1+ (/ LH.STATISTICS::SAMPLE-RATIO))))
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (/ (* LH.STATISTICS::P2 LH.STATISTICS::Q2) LH.STATISTICS::SAMPLE-RATIO)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The second argument is a (REAL (0)), not a INTEGER.The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (SQRT
;      (+ (* LH.STATISTICS::P1 LH.STATISTICS::Q1)
;         (/ (* LH.STATISTICS::P2 LH.STATISTICS::Q2) LH.STATISTICS::SAMPLE-RATIO)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0), not a DOUBLE-FLOAT.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::P1 :PROB)
;                                   (LH.STATISTICS::P2 :PROB)
;                                   (LH.STATISTICS::ALPHA :PROB)
;                                   (LH.STATISTICS::1-BETA :PROB)
;                                   (LH.STATISTICS::SAMPLE-RATIO :POSNUM))
; --> LET IF LET IF LET IF LET IF UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

;     (- 1 LH.STATISTICS::P1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- 1 LH.STATISTICS::P2)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::P1 LH.STATISTICS::P2)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL -1 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL -1 1) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

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

;     (* LH.STATISTICS::SAMPLE-RATIO LH.STATISTICS::P2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::P1 (* LH.STATISTICS::SAMPLE-RATIO LH.STATISTICS::P2))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (1+ LH.STATISTICS::SAMPLE-RATIO)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The result is a (VALUES (OR (FLOAT 1.0) (RATIONAL (1))) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The result is a (VALUES (OR (FLOAT 1.0) (RATIONAL (1))) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (/ (+ LH.STATISTICS::P1 (* LH.STATISTICS::SAMPLE-RATIO LH.STATISTICS::P2))
;        (1+ LH.STATISTICS::SAMPLE-RATIO))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       The second argument is a (OR (FLOAT 1.0) (RATIONAL (1))), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (REAL 0), not a DOUBLE-FLOAT.
;       The second argument is a (OR (FLOAT 1.0) (RATIONAL (1))), not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (- 1 LH.STATISTICS::P-BAR)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL * 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL * 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- 1
;        (IF (EQL LH.STATISTICS::TAILS :BOTH)
;            (/ LH.STATISTICS::ALPHA 2)
;            LH.STATISTICS::ALPHA))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P-BAR LH.STATISTICS::Q-BAR
;        (1+ (/ LH.STATISTICS::SAMPLE-RATIO)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The second argument is a (REAL * 1), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL * 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (1+ (/ LH.STATISTICS::SAMPLE-RATIO))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P-BAR LH.STATISTICS::Q-BAR
;        (1+ (/ LH.STATISTICS::SAMPLE-RATIO)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a (REAL 1), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (*
;      (SQRT
;       (* LH.STATISTICS::P-BAR LH.STATISTICS::Q-BAR
;          (1+ (/ LH.STATISTICS::SAMPLE-RATIO))))
;      LH.STATISTICS::Z-ALPHA)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P1 LH.STATISTICS::Q1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P2 LH.STATISTICS::Q2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/ (* LH.STATISTICS::P2 LH.STATISTICS::Q2) LH.STATISTICS::SAMPLE-RATIO)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The second argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (REAL 0 1), not a DOUBLE-FLOAT.
;       The second argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (+ (* LH.STATISTICS::P1 LH.STATISTICS::Q1)
;        (/ (* LH.STATISTICS::P2 LH.STATISTICS::Q2) LH.STATISTICS::SAMPLE-RATIO))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (*
;      (SQRT
;       (+ (* LH.STATISTICS::P1 LH.STATISTICS::Q1)
;          (/ (* LH.STATISTICS::P2 LH.STATISTICS::Q2)
;             LH.STATISTICS::SAMPLE-RATIO)))
;      LH.STATISTICS::Z-BETA)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (FLOAT 0.0), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (FLOAT 0.0), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (+
;      (* (SQRT (* LH.STATISTICS::P-BAR LH.STATISTICS::Q-BAR (1+ #)))
;         LH.STATISTICS::Z-ALPHA)
;      (*
;       (SQRT
;        (+ (* LH.STATISTICS::P1 LH.STATISTICS::Q1)
;           (/ # LH.STATISTICS::SAMPLE-RATIO)))
;       LH.STATISTICS::Z-BETA))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P-BAR LH.STATISTICS::Q-BAR
;        (1+ (/ LH.STATISTICS::SAMPLE-RATIO)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The second argument is a (REAL * 1), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL * 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (1+ (/ LH.STATISTICS::SAMPLE-RATIO))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P-BAR LH.STATISTICS::Q-BAR
;        (1+ (/ LH.STATISTICS::SAMPLE-RATIO)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a (REAL 1), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (*
;      (SQRT
;       (* LH.STATISTICS::P-BAR LH.STATISTICS::Q-BAR
;          (1+ (/ LH.STATISTICS::SAMPLE-RATIO))))
;      LH.STATISTICS::Z-ALPHA)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P1 LH.STATISTICS::Q1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P2 LH.STATISTICS::Q2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/ (* LH.STATISTICS::P2 LH.STATISTICS::Q2) LH.STATISTICS::SAMPLE-RATIO)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The second argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (REAL 0 1), not a DOUBLE-FLOAT.
;       The second argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (+ (* LH.STATISTICS::P1 LH.STATISTICS::Q1)
;        (/ (* LH.STATISTICS::P2 LH.STATISTICS::Q2) LH.STATISTICS::SAMPLE-RATIO))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (*
;      (SQRT
;       (+ (* LH.STATISTICS::P1 LH.STATISTICS::Q1)
;          (/ (* LH.STATISTICS::P2 LH.STATISTICS::Q2)
;             LH.STATISTICS::SAMPLE-RATIO)))
;      LH.STATISTICS::Z-BETA)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (FLOAT 0.0), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (FLOAT 0.0), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (+
;      (* (SQRT (* LH.STATISTICS::P-BAR LH.STATISTICS::Q-BAR (1+ #)))
;         LH.STATISTICS::Z-ALPHA)
;      (*
;       (SQRT
;        (+ (* LH.STATISTICS::P1 LH.STATISTICS::Q1)
;           (/ # LH.STATISTICS::SAMPLE-RATIO)))
;       LH.STATISTICS::Z-BETA))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE
;      (+
;       (* (SQRT (* LH.STATISTICS::P-BAR LH.STATISTICS::Q-BAR #))
;          LH.STATISTICS::Z-ALPHA)
;       (* (SQRT (+ # #)) LH.STATISTICS::Z-BETA)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE LH.STATISTICS::DELTA)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/
;      (LH.STATISTICS:SQUARE
;       (+ (* (SQRT #) LH.STATISTICS::Z-ALPHA) (* (SQRT #) LH.STATISTICS::Z-BETA)))
;      (LH.STATISTICS:SQUARE LH.STATISTICS::DELTA))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (REAL 0 1), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (REAL 0 1), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* LH.STATISTICS::SAMPLE-RATIO LH.STATISTICS::N1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN BINOMIAL-TEST-PAIRED-SSE
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::PD :PROB)
;                                   (LH.STATISTICS::PA :POSNUM)
;                                   (LH.STATISTICS::ALPHA :PROB)
;                                   (LH.STATISTICS::1-BETA :PROB))
; --> LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.

;     (/ LH.STATISTICS::ALPHA 2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 0 1/2) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (REAL 0 1), not a INTEGER.

;     (* 2 LH.STATISTICS::Z-BETA (SQRT (* LH.STATISTICS::PA LH.STATISTICS::QA)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.

;     (SQRT (* LH.STATISTICS::PA LH.STATISTICS::QA))
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (* 2 LH.STATISTICS::Z-BETA (SQRT (* LH.STATISTICS::PA LH.STATISTICS::QA)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.

;     (SQRT (* LH.STATISTICS::PA LH.STATISTICS::QA))
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (* 2 (LH.STATISTICS:SQUARE (- LH.STATISTICS::PA 1/2)) LH.STATISTICS::PD)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::PD :PROB)
;                                   (LH.STATISTICS::PA :POSNUM)
;                                   (LH.STATISTICS::ALPHA :PROB)
;                                   (LH.STATISTICS::1-BETA :PROB))
; --> LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

;     (- 1 LH.STATISTICS::PA)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL (0)), not a FIXNUM.
;       The result is a (VALUES (OR (FLOAT * 1.0) (RATIONAL * (1))) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (OR (FLOAT * 1.0) (RATIONAL * (1))) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- 1
;        (IF (EQL LH.STATISTICS::TAILS :BOTH)
;            (/ LH.STATISTICS::ALPHA 2)
;            LH.STATISTICS::ALPHA))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::PA LH.STATISTICS::QA)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The second argument is a (OR (FLOAT * 1.0) (RATIONAL * (1))), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The second argument is a (OR (FLOAT * 1.0) (RATIONAL * (1))), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 LH.STATISTICS::Z-BETA (SQRT (* LH.STATISTICS::PA LH.STATISTICS::QA)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::Z-ALPHA
;        (* 2 LH.STATISTICS::Z-BETA (SQRT (* LH.STATISTICS::PA LH.STATISTICS::QA))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::PA LH.STATISTICS::QA)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL (0)), not a FIXNUM.
;       The second argument is a (OR (FLOAT * 1.0) (RATIONAL * (1))), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (REAL (0)), not a (UNSIGNED-BYTE 64).
;       The second argument is a (OR (FLOAT * 1.0) (RATIONAL * (1))), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 LH.STATISTICS::Z-BETA (SQRT (* LH.STATISTICS::PA LH.STATISTICS::QA)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (+ LH.STATISTICS::Z-ALPHA
;        (* 2 LH.STATISTICS::Z-BETA (SQRT (* LH.STATISTICS::PA LH.STATISTICS::QA))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE
;      (+ LH.STATISTICS::Z-ALPHA
;         (* 2 LH.STATISTICS::Z-BETA
;            (SQRT (* LH.STATISTICS::PA LH.STATISTICS::QA)))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE (- LH.STATISTICS::PA 1/2))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (FLOAT -0.5) (RATIONAL (-1/2))), not a FIXNUM.
;       The second argument is a (OR (FLOAT -0.5) (RATIONAL (-1/2))), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (FLOAT -0.5) (RATIONAL (-1/2))), not a (UNSIGNED-BYTE 64).
;       The second argument is a (OR (FLOAT -0.5) (RATIONAL (-1/2))), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 (LH.STATISTICS:SQUARE (- LH.STATISTICS::PA 1/2)) LH.STATISTICS::PD)
; 
; note: forced to do GENERIC-* (cost 30)
;       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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/
;      (LH.STATISTICS:SQUARE
;       (+ LH.STATISTICS::Z-ALPHA (* 2 LH.STATISTICS::Z-BETA (SQRT #))))
;      (* 2 (LH.STATISTICS:SQUARE (- LH.STATISTICS::PA 1/2)) LH.STATISTICS::PD))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

; in: DEFUN CORRELATION-SSE
;     (- 1 LH.STATISTICS::ALPHA)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ (LH.STATISTICS:Z (- 1 LH.STATISTICS::ALPHA))
;        (LH.STATISTICS:Z LH.STATISTICS::1-BETA))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (- 1 LH.STATISTICS::ALPHA)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ (LH.STATISTICS:Z (- 1 LH.STATISTICS::ALPHA))
;        (LH.STATISTICS:Z LH.STATISTICS::1-BETA))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE
;      (+ (LH.STATISTICS:Z (- 1 LH.STATISTICS::ALPHA))
;         (LH.STATISTICS:Z LH.STATISTICS::1-BETA)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE (LH.STATISTICS:FISHER-Z-TRANSFORM LH.STATISTICS::RHO))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/
;      (LH.STATISTICS:SQUARE
;       (+ (LH.STATISTICS:Z (- 1 LH.STATISTICS::ALPHA))
;          (LH.STATISTICS:Z LH.STATISTICS::1-BETA)))
;      (LH.STATISTICS:SQUARE (LH.STATISTICS:FISHER-Z-TRANSFORM LH.STATISTICS::RHO)))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

; in: DEFUN LINEAR-REGRESSION
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::POINTS SEQUENCE))
; --> THE UNLESS IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

;     (LENGTH LH.STATISTICS::POINTS)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (ZEROP LH.STATISTICS::LXX)
; 
; 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.

;     (/ LH.STATISTICS::LXY LH.STATISTICS::LXX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (/ (- LH.STATISTICS::LYY LH.STATISTICS::REG-SS) (- LH.STATISTICS::N 2))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (ZEROP LH.STATISTICS::LXX)
; 
; 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.

;     (ZEROP LH.STATISTICS::LXY)
; 
; 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.

;     (SQRT (* LH.STATISTICS::LXX LH.STATISTICS::LYY))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-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 (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (ZEROP LH.STATISTICS::LYY)
; 
; 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.

;     (/ LH.STATISTICS::REG-SS LH.STATISTICS::LYY)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (ZEROP LH.STATISTICS::LXX)
; 
; 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.

;     (ZEROP LH.STATISTICS::RES-MS)
; 
; 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.

;     (/ LH.STATISTICS::RES-MS LH.STATISTICS::LXX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (SQRT (/ LH.STATISTICS::RES-MS LH.STATISTICS::LXX))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-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 (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (- LH.STATISTICS::XI LH.STATISTICS::X-BAR)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) 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 &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::YI LH.STATISTICS::Y-BAR)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) 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 &OPTIONAL).
;       etc.

;     (* (- LH.STATISTICS::XI LH.STATISTICS::X-BAR)
;        (- LH.STATISTICS::YI LH.STATISTICS::Y-BAR))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/ LH.STATISTICS::LXY LH.STATISTICS::LXX)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) 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 &OPTIONAL).
;       unable to do inline float arithmetic (cost 12) 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) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::B LH.STATISTICS::X-BAR)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::Y-BAR (* LH.STATISTICS::B LH.STATISTICS::X-BAR))
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::B LH.STATISTICS::LXY)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR NUMBER NULL), not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR NUMBER NULL), not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::LYY LH.STATISTICS::REG-SS)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) 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 &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::LXX LH.STATISTICS::LYY)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/ LH.STATISTICS::LXY (SQRT (* LH.STATISTICS::LXX LH.STATISTICS::LYY)))
; 
; 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 (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (/ LH.STATISTICS::REG-SS LH.STATISTICS::LYY)
; 
; 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 NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (/ LH.STATISTICS::RES-MS LH.STATISTICS::LXX)
; 
; 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 NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (/ LH.STATISTICS::B (SQRT (/ LH.STATISTICS::RES-MS LH.STATISTICS::LXX)))
; 
; 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 (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::YI LH.STATISTICS::Y-BAR)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) 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 &OPTIONAL).
;       etc.
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE (- LH.STATISTICS::YI LH.STATISTICS::Y-BAR))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::XI LH.STATISTICS::X-BAR)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) 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 &OPTIONAL).
;       etc.
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE (- LH.STATISTICS::XI LH.STATISTICS::X-BAR))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN CORRELATION-COEFFICIENT
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::POINTS SEQUENCE))
; --> THE UNLESS IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

;     (SQRT
;      (* (REDUCE #'+ (MAPCAR #'(LAMBDA # #) LH.STATISTICS::XS))
;         (REDUCE #'+ (MAPCAR #'(LAMBDA # #) LH.STATISTICS::YS))))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-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 (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (- LH.STATISTICS::XI LH.STATISTICS::X-BAR)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) 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 &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::YI LH.STATISTICS::Y-BAR)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) 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 &OPTIONAL).
;       etc.

;     (* (- LH.STATISTICS::XI LH.STATISTICS::X-BAR)
;        (- LH.STATISTICS::YI LH.STATISTICS::Y-BAR))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (*
;      (REDUCE #'+
;              (MAPCAR #'(LAMBDA (LH.STATISTICS::XI) (LH.STATISTICS:SQUARE #))
;                      LH.STATISTICS::XS))
;      (REDUCE #'+
;              (MAPCAR #'(LAMBDA (LH.STATISTICS::YI) (LH.STATISTICS:SQUARE #))
;                      LH.STATISTICS::YS)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/
;      (REDUCE #'+
;              (MAPCAR #'(LAMBDA (LH.STATISTICS::XI LH.STATISTICS::YI) (* # #))
;                      LH.STATISTICS::XS LH.STATISTICS::YS))
;      (SQRT
;       (* (REDUCE #'+ (MAPCAR #'# LH.STATISTICS::XS))
;          (REDUCE #'+ (MAPCAR #'# LH.STATISTICS::YS)))))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::YI LH.STATISTICS::Y-BAR)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) 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 &OPTIONAL).
;       etc.
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE (- LH.STATISTICS::YI LH.STATISTICS::Y-BAR))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::XI LH.STATISTICS::X-BAR)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) 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 &OPTIONAL).
;       etc.
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE (- LH.STATISTICS::XI LH.STATISTICS::X-BAR))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN CORRELATION-TEST-TWO-SAMPLE
;     (/ (- LH.STATISTICS::N1 3))
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (RATIONAL -1 -1/2) (RATIONAL (0) 1)) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (/ (- LH.STATISTICS::N2 3))
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (RATIONAL -1 -1/2) (RATIONAL (0) 1)) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (* 2
;        (IF (<= LAMBDA 0)
;            (LH.STATISTICS:PHI LAMBDA)
;            (- 1 (LH.STATISTICS:PHI LAMBDA))))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::R1 :PROB)
;                                   (LH.STATISTICS::N1 :POSINT)
;                                   (LH.STATISTICS::R2 :PROB)
;                                   (LH.STATISTICS::N2 :POSINT))
; --> LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   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.

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

;     (- LH.STATISTICS::Z1 LH.STATISTICS::Z2)
; 
; 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 T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::N1 3)
; 
; 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 (INTEGER -2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES (INTEGER -2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::N2 3)
; 
; 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 (INTEGER -2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES (INTEGER -2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (+ (/ (- LH.STATISTICS::N1 3)) (/ (- LH.STATISTICS::N2 3)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (RATIONAL -1 -1/2) (RATIONAL (0) 1)), not a FIXNUM.
;       The second argument is a (OR (RATIONAL -1 -1/2) (RATIONAL (0) 1)), not a FIXNUM.
;       The result is a (VALUES (RATIONAL -2 2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (RATIONAL -1 -1/2) (RATIONAL (0) 1)), not a (UNSIGNED-BYTE 64).
;       The second argument is a (OR (RATIONAL -1 -1/2) (RATIONAL (0) 1)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (RATIONAL -2 2) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/ (- LH.STATISTICS::Z1 LH.STATISTICS::Z2)
;        (SQRT (+ (/ (- LH.STATISTICS::N1 3)) (/ (- LH.STATISTICS::N2 3)))))
; 
; 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 (OR (COMPLEX SINGLE-FLOAT) (SINGLE-FLOAT 0.0 1.4142135)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 (OR (COMPLEX SINGLE-FLOAT) (SINGLE-FLOAT 0.0 1.4142135)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).

;     (* 2
;        (IF (<= LAMBDA 0)
;            (LH.STATISTICS:PHI LAMBDA)
;            (- 1 (LH.STATISTICS:PHI LAMBDA))))
; 
; note: forced to do GENERIC-* (cost 30)
;       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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

; in: DEFUN CORRELATION-TEST-TWO-SAMPLE-ON-SEQUENCES
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::POINTS1 SEQUENCE)
;                                   (LH.STATISTICS::POINTS2 SEQUENCE))
; --> LET UNLESS IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

; --> LET IF UNLESS IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

;     (LENGTH LH.STATISTICS::POINTS1)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (LENGTH LH.STATISTICS::POINTS2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; in: DEFUN SPEARMAN-RANK-CORRELATION
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::POINTS SEQUENCE))
; --> THE UNLESS IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

;     (LENGTH LH.STATISTICS::POINTS)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (SQRT (* LH.STATISTICS::LXX LH.STATISTICS::LYY))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-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 (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (SQRT (- 1 (LH.STATISTICS:SQUARE LH.STATISTICS::RS)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (FLOAT * 1.0) (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0 1.0) (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 (OR (FLOAT * 1.0) (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.The result is a (VALUES (OR (FLOAT 0.0 1.0) (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (- LH.STATISTICS::XI-RANK LH.STATISTICS::MEAN-X-RANK)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) 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 &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::YI-RANK LH.STATISTICS::MEAN-Y-RANK)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) 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 &OPTIONAL).
;       etc.

;     (* (- LH.STATISTICS::XI-RANK LH.STATISTICS::MEAN-X-RANK)
;        (- LH.STATISTICS::YI-RANK LH.STATISTICS::MEAN-Y-RANK))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::LXX LH.STATISTICS::LYY)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/ LH.STATISTICS::LXY (SQRT (* LH.STATISTICS::LXX LH.STATISTICS::LYY)))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::RS (SQRT (- LH.STATISTICS::N 2)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The second argument is a (OR (COMPLEX SINGLE-FLOAT) (SINGLE-FLOAT 0.0 4194304.0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The second argument is a (OR (COMPLEX SINGLE-FLOAT) (SINGLE-FLOAT 0.0 4194304.0)), not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE LH.STATISTICS::RS)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The second argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The second argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES (OR (FLOAT 0.0) (COMPLEX DOUBLE-FLOAT) (COMPLEX SINGLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (/ (* LH.STATISTICS::RS (SQRT (- LH.STATISTICS::N 2)))
;        (SQRT (- 1 (LH.STATISTICS:SQUARE LH.STATISTICS::RS))))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The second argument is a (OR (FLOAT 0.0 1.0) (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a (OR (FLOAT 0.0 1.0) (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::YI-RANK LH.STATISTICS::MEAN-Y-RANK)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) 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 &OPTIONAL).
;       etc.
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE (- LH.STATISTICS::YI-RANK LH.STATISTICS::MEAN-Y-RANK))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- LH.STATISTICS::XI-RANK LH.STATISTICS::MEAN-X-RANK)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) 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 &OPTIONAL).
;       etc.
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS:SQUARE (- LH.STATISTICS::XI-RANK LH.STATISTICS::MEAN-X-RANK))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN T-SIGNIFICANCE
;     (FLOAT LH.STATISTICS::DOF LH.STATISTICS::T-STATISTIC)
; 
; 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.

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::T-STATISTIC NUMBER)
;                                   (LH.STATISTICS::DOF :POSINT))
; --> LET IF UNLESS IF AND IF PLUSP 
; ==>
;   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.

;     (* 0.5 LH.STATISTICS::DOF)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (FLOAT 1.0), not a SINGLE-FLOAT.
;       The result is a (VALUES (FLOAT 0.5) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).

;     (LH.STATISTICS:SQUARE LH.STATISTICS::T-STATISTIC)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a FLOAT, not a SINGLE-FLOAT.
;       The second argument is a FLOAT, not a SINGLE-FLOAT.
;       The result is a (VALUES (FLOAT 0.0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a FLOAT, not a DOUBLE-FLOAT.
;       The second argument is a FLOAT, not a DOUBLE-FLOAT.
;       The result is a (VALUES (FLOAT 0.0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (+ LH.STATISTICS::DOF (LH.STATISTICS:SQUARE LH.STATISTICS::T-STATISTIC))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (FLOAT 1.0), not a SINGLE-FLOAT.
;       The second argument is a (FLOAT 0.0), not a SINGLE-FLOAT.
;       The result is a (VALUES (FLOAT 1.0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (FLOAT 1.0), not a DOUBLE-FLOAT.
;       The second argument is a (FLOAT 0.0), not a DOUBLE-FLOAT.
;       The result is a (VALUES (FLOAT 1.0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (/ LH.STATISTICS::DOF
;        (+ LH.STATISTICS::DOF (LH.STATISTICS:SQUARE LH.STATISTICS::T-STATISTIC)))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (FLOAT 1.0), not a SINGLE-FLOAT.
;       The second argument is a (FLOAT 1.0), not a SINGLE-FLOAT.
;       The result is a (VALUES (FLOAT 0.0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (FLOAT 1.0), not a DOUBLE-FLOAT.
;       The second argument is a (FLOAT 1.0), not a DOUBLE-FLOAT.
;       The result is a (VALUES (FLOAT 0.0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (* 0.5 LH.STATISTICS::A)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).

;     (- 1.0 (* 0.5 LH.STATISTICS::A))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The second argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The second argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).

;     (* 0.5 LH.STATISTICS::A)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).

;     (- 1.0 (* 0.5 LH.STATISTICS::A))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The second argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The second argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).

; in: DEFUN F-SIGNIFICANCE
;     (* 2.0 LH.STATISTICS::TAIL-AREA)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.

;     (FLOAT LH.STATISTICS::F-STATISTIC)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a RATIONAL, not a (SIGNED-BYTE 64).

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::F-STATISTIC :POSNUM)
;                                   (LH.STATISTICS::NUMERATOR-DOF :POSINT)
;                                   (LH.STATISTICS::DENOMINATOR-DOF :POSINT))
; --> LET IF LET UNLESS IF AND IF PLUSP 
; ==>
;   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.

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

;     (* 0.5d0 LH.STATISTICS::DENOMINATOR-DOF)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (INTEGER 4611686018427387904), not a (SIGNED-BYTE 64).

;     (* 0.5d0 LH.STATISTICS::NUMERATOR-DOF)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (INTEGER 4611686018427387904), not a (SIGNED-BYTE 64).

;     (* 2.0 LH.STATISTICS::TAIL-AREA)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).

;     (- 2.0 LH.STATISTICS::TAIL-AREA)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The second argument is a (FLOAT (1.0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (FLOAT * 1.0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).

;     (- 1 LH.STATISTICS::TAIL-AREA)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (FLOAT
;      (/ LH.STATISTICS::DENOMINATOR-DOF
;         (+ LH.STATISTICS::DENOMINATOR-DOF
;            (* LH.STATISTICS::NUMERATOR-DOF LH.STATISTICS::F-STATISTIC)))
;      1.0d0)
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first result of inline float coercion

;     (LH.STATISTICS::BETA-INCOMPLETE (* 0.5d0 LH.STATISTICS::DENOMINATOR-DOF)
;      (* 0.5d0 LH.STATISTICS::NUMERATOR-DOF)
;      (FLOAT
;       (/ LH.STATISTICS::DENOMINATOR-DOF
;          (+ LH.STATISTICS::DENOMINATOR-DOF
;             (* LH.STATISTICS::NUMERATOR-DOF LH.STATISTICS::F-STATISTIC)))
;       1.0d0))
; 
; note: doing float to pointer coercion (cost 13)
; 
; note: doing float to pointer coercion (cost 13)

; in: DEFUN RANDOM-PICK
;     (LH.STATISTICS:TEST-VARIABLES (SEQUENCE SEQUENCE))
; --> THE UNLESS IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

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

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

; in: DEFUN RANDOM-NORMAL
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS:MEAN NUMBER)
;                                   (LH.STATISTICS:SD :POSNUM))
; --> LET IF UNLESS IF AND IF PLUSP 
; ==>
;   1
; 
; 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.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.

;     (* LH.STATISTICS:SD LH.STATISTICS::RANDOM-STANDARD)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (REAL (0)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (+ LH.STATISTICS:MEAN (* LH.STATISTICS:SD LH.STATISTICS::RANDOM-STANDARD))
; 
; 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 DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (RANDOM 1.0d0)
; 
; note: doing float to pointer coercion (cost 13)

; in: DEFUN BIN-AND-COUNT
;     (/ (- (REDUCE #'MAX SEQUENCE) MIN) LH.STATISTICS::N)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (>= LH.STATISTICS::X (+ MIN (* LH.STATISTICS::BIN LH.STATISTICS::INCREMENT)))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.

;     (< LH.STATISTICS::X
;        (+ MIN (* (1+ LH.STATISTICS::BIN) LH.STATISTICS::INCREMENT)))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.

;     (* LH.STATISTICS::BIN LH.STATISTICS::INCREMENT)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ MIN (* LH.STATISTICS::BIN LH.STATISTICS::INCREMENT))
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) 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 &OPTIONAL).
;       etc.

;     (>= LH.STATISTICS::X (+ MIN (* LH.STATISTICS::BIN LH.STATISTICS::INCREMENT)))
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.

;     (1+ LH.STATISTICS::BIN)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (* (1+ LH.STATISTICS::BIN) LH.STATISTICS::INCREMENT)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ MIN (* (1+ LH.STATISTICS::BIN) LH.STATISTICS::INCREMENT))
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (< LH.STATISTICS::X
;        (+ MIN (* (1+ LH.STATISTICS::BIN) LH.STATISTICS::INCREMENT)))
; 
; 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 NUMBER, 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 NUMBER, not a DOUBLE-FLOAT.
;       etc.

;     (- (REDUCE #'MAX SEQUENCE) MIN)
; 
; 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 T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (/ (- (REDUCE #'MAX SEQUENCE) MIN) LH.STATISTICS::N)
; 
; 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 &OPTIONAL).
;       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) &OPTIONAL).
;       etc.

;     (DOTIMES (LH.STATISTICS::BIN LH.STATISTICS::N LH.STATISTICS::BINS)
;       (SETF (AREF LH.STATISTICS::BINS LH.STATISTICS::BIN)
;               (COUNT-IF #'(LAMBDA # #) SEQUENCE)))
; --> BLOCK LET TAGBODY PSETQ PROGN SETQ THE 1+ 
; ==>
;   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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

; in: DEFUN FISHER-Z-TRANSFORM
;     (/ (1+ LH.STATISTICS::R) (- 1 LH.STATISTICS::R))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 1 2), not a INTEGER.The second argument is a (REAL 0 1), not a INTEGER.The result is a (VALUES (REAL 1) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (LOG (/ (1+ LH.STATISTICS::R) (- 1 LH.STATISTICS::R)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 1), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (REAL 1), not a DOUBLE-FLOAT.

;     (1+ LH.STATISTICS::R)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 1 2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 1 2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- 1 LH.STATISTICS::R)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (REAL 0 1), not a FIXNUM.
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (REAL 0 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (REAL 0 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/ (1+ LH.STATISTICS::R) (- 1 LH.STATISTICS::R))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (REAL 1 2), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0 1), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 1) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (REAL 1 2), not a DOUBLE-FLOAT.
;       The second argument is a (REAL 0 1), not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 1) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

; in: DEFUN PERMUTATIONS
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::N :POSINT)
;                                   (LH.STATISTICS::K :POSINT)
;                                   ("K must be less than or equal to N" :TEST
;                                    (<= LH.STATISTICS::K LH.STATISTICS::N)))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   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.

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

;     (<= LH.STATISTICS::K LH.STATISTICS::N)
; 
; 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 1), not a FIXNUM.

;     (1+ LH.STATISTICS::K)
; 
; 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 (INTEGER 2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (DOTIMES (LH.STATISTICS::I (1+ LH.STATISTICS::K) LH.STATISTICS::P)
;       (SETQ LH.STATISTICS::P
;               (* LH.STATISTICS::P (- LH.STATISTICS::N LH.STATISTICS::I))))
; --> BLOCK LET TAGBODY UNLESS IF >= 
; ==>
;   1
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a (INTEGER 2), not a FIXNUM.

;     (- LH.STATISTICS::N LH.STATISTICS::I)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::P (- LH.STATISTICS::N LH.STATISTICS::I))
; 
; note: forced to do GENERIC-* (cost 30)
;       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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (DOTIMES (LH.STATISTICS::I (1+ LH.STATISTICS::K) LH.STATISTICS::P)
;       (SETQ LH.STATISTICS::P
;               (* LH.STATISTICS::P (- LH.STATISTICS::N LH.STATISTICS::I))))
; --> BLOCK LET TAGBODY PSETQ PROGN SETQ THE 1+ 
; ==>
;   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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

; in: DEFUN CHOOSE
;     (>= LH.STATISTICS::K 0)
; 
; 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.

;     (<= LH.STATISTICS::K LH.STATISTICS::N)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0), not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0), not a DOUBLE-FLOAT.

;     (/ (LH.STATISTICS::FACTORIAL LH.STATISTICS::N)
;        (* (LH.STATISTICS::FACTORIAL LH.STATISTICS::K)
;           (LH.STATISTICS::FACTORIAL (- LH.STATISTICS::N LH.STATISTICS::K))))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::N :POSINT)
;                                   ("K must be between 0 and N (inclusive)" :TEST
;                                    (AND (>= LH.STATISTICS::K 0)
;                                         (<= LH.STATISTICS::K LH.STATISTICS::N))))
; --> LET UNLESS IF AND IF PLUSP 
; ==>
;   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.

;     (- LH.STATISTICS::N LH.STATISTICS::K)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The second argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a (REAL 0), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* (LH.STATISTICS::FACTORIAL LH.STATISTICS::K)
;        (LH.STATISTICS::FACTORIAL (- LH.STATISTICS::N LH.STATISTICS::K)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (/ (LH.STATISTICS::FACTORIAL LH.STATISTICS::N)
;        (* (LH.STATISTICS::FACTORIAL LH.STATISTICS::K)
;           (LH.STATISTICS::FACTORIAL (- LH.STATISTICS::N LH.STATISTICS::K))))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) 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 &OPTIONAL).
;       unable to do inline float arithmetic (cost 12) 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) &OPTIONAL).
;       etc.

; in: DEFUN MEAN-SD-N
;     (LENGTH SEQUENCE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS VECTOR SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

;     (LH.STATISTICS:TEST-VARIABLES (SEQUENCE :NUMSEQ))
; --> THE UNLESS IF AND IF IF TYPEP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFUN ROUND-FLOAT
;     (LH.STATISTICS:TEST-VARIABLES (LH.STATISTICS::X NUMBER)
;                                   (LH.STATISTICS::PRECISION :POSINT))
; --> LET IF UNLESS IF AND IF PLUSP 
; ==>
;   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.

;     (- LH.STATISTICS::PRECISION)
; 
; 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 &OPTIONAL).
;       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) &OPTIONAL).
;       etc.

; in: DEFUN FALSE-DISCOVERY-CORRECTION
;     (LENGTH LH.STATISTICS::P-VALUES)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (SORT LH.STATISTICS::P-VALUES #'>)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a LIST.

;     (/ LH.STATISTICS::TESTS-TO-GO LH.STATISTICS::NUMBER-OF-TESTS)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (RATIONAL * 17592186044415) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (<= LH.STATISTICS::P-VALUE
;         (* LH.STATISTICS::RATE
;            (/ LH.STATISTICS::TESTS-TO-GO LH.STATISTICS::NUMBER-OF-TESTS)))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.

;     (/ LH.STATISTICS::TESTS-TO-GO LH.STATISTICS::NUMBER-OF-TESTS)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (RATIONAL * 17592186044415) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (* LH.STATISTICS::RATE
;        (/ LH.STATISTICS::TESTS-TO-GO LH.STATISTICS::NUMBER-OF-TESTS))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (RATIONAL * 17592186044415), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (RATIONAL * 17592186044415), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (<= LH.STATISTICS::P-VALUE
;         (* LH.STATISTICS::RATE
;            (/ LH.STATISTICS::TESTS-TO-GO LH.STATISTICS::NUMBER-OF-TESTS)))
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (NOT NULL), not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.

;     (1- LH.STATISTICS::TESTS-TO-GO)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER * 17592186044415), not a FIXNUM.
;       The result is a (VALUES (INTEGER * 17592186044414) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER * 17592186044415), not a FIXNUM.
;       The result is a (VALUES (INTEGER * 17592186044414) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::RATE
;        (/ LH.STATISTICS::TESTS-TO-GO LH.STATISTICS::NUMBER-OF-TESTS))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (RATIONAL * 17592186044415), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (RATIONAL * 17592186044415), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN ROUND-UP
;     (CEILING LH.STATISTICS::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.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to convert division by 2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to fold division by 1 due to type uncertainty: The first argument is a REAL, not a INTEGER.

; in: DEFUN SIGN
;     (MINUSP LH.STATISTICS::X)
; 
; 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.

;     (PLUSP LH.STATISTICS::X)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0), not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0), not a DOUBLE-FLOAT.

;     (MINUSP LH.STATISTICS::X)
; 
; 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.

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

; in: DEFUN FACTORIAL
;     (= 0 LH.STATISTICS::NUM)
; 
; 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.

;     (>= NUMBER 0)
; 
; 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.

;     (1- LH.STATISTICS::NUM)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (* LH.STATISTICS::NUM (LH.STATISTICS::FACT (1- LH.STATISTICS::NUM)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN AVERAGE-RANK
;     (POSITION LH.STATISTICS::VALUE LH.STATISTICS::SORTED-VALUES)
; 
; note: unable to optimize due to type uncertainty: The second argument is a SEQUENCE, not a (OR LIST VECTOR).

;     (POSITION LH.STATISTICS::VALUE LH.STATISTICS::SORTED-VALUES :FROM-END T)
; 
; note: unable to optimize due to type uncertainty: The second argument is a SEQUENCE, not a (OR LIST VECTOR).

;     (/ (+ FIRST LAST) 2)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (RATIONAL 0 17592186044414) &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (1+
;      (IF (= FIRST LAST)
;          FIRST
;          (/ (+ FIRST LAST) 2)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (RATIONAL 0 17592186044414), not a FIXNUM.
;       The result is a (VALUES (RATIONAL 1 17592186044415) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL 0 17592186044414), not a FIXNUM.
;       The result is a (VALUES (RATIONAL 1 17592186044415) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

; in: DEFUN ERROR-FUNCTION
;     (>= LH.STATISTICS::X 0.0d0)
; 
; note: unable to open-code RATIONAL to FLOAT comparison due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (- LH.STATISTICS::ERF)
; 
; note: unable to Eliminate %negate/%negate of rationals due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (COERCE LH.STATISTICS::X '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).
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).

;     (>= LH.STATISTICS::X 0.0d0)
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.

;     (- LH.STATISTICS::ERF)
; 
; note: forced to do GENERIC-NEGATE (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 &OPTIONAL).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (LH.STATISTICS::GAMMA-INCOMPLETE 0.5d0
;      (LH.STATISTICS:SQUARE (COERCE LH.STATISTICS::X 'DOUBLE-FLOAT)))
; 
; note: doing float to pointer coercion (cost 13)

; in: DEFUN GAMMA-INCOMPLETE
;     (LOG LH.STATISTICS::X)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (= LH.STATISTICS::X 0.0)
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to open-code RATIONAL to FLOAT comparison due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (LOG LH.STATISTICS::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The result is a (VALUES (OR 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 REAL, not a DOUBLE-FLOAT.The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (COERCE LH.STATISTICS::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).

;     (= LH.STATISTICS::X 0.0)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).

;     (< LH.STATISTICS::X (+ LH.STATISTICS::A 1.0d0))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.

;     (* LH.STATISTICS::A (LOG LH.STATISTICS::X))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (- (* LH.STATISTICS::A (LOG LH.STATISTICS::X)) LH.STATISTICS::X
;        LH.STATISTICS::GLN)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (*
;      (LH.STATISTICS::SAFE-EXP
;       (- (* LH.STATISTICS::A (LOG LH.STATISTICS::X)) LH.STATISTICS::X
;          LH.STATISTICS::GLN))
;      LH.STATISTICS::G)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (- 1.0d0 LH.STATISTICS::RESULT)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (/ LH.STATISTICS::X LH.STATISTICS::AP)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).

;     (* LH.STATISTICS::A (LOG LH.STATISTICS::X))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The second argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The second argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (- (* LH.STATISTICS::A (LOG LH.STATISTICS::X)) LH.STATISTICS::X
;        LH.STATISTICS::GLN)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* LH.STATISTICS::SUM
;        (LH.STATISTICS::SAFE-EXP
;         (- (* LH.STATISTICS::A (LOG LH.STATISTICS::X)) LH.STATISTICS::X
;            LH.STATISTICS::GLN)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The second argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (SETQ LH.STATISTICS::A (COERCE LH.STATISTICS::A 'DOUBLE-FLOAT))
; 
; note: doing float to pointer coercion (cost 13) to A

;     (< LH.STATISTICS::X (+ LH.STATISTICS::A 1.0d0))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-<

;     (* LH.STATISTICS::SUM
;        (LH.STATISTICS::SAFE-EXP
;         (- (* LH.STATISTICS::A (LOG LH.STATISTICS::X)) LH.STATISTICS::X
;            LH.STATISTICS::GLN)))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first argument of GENERIC-*

;     (*
;      (LH.STATISTICS::SAFE-EXP
;       (- (* LH.STATISTICS::A (LOG LH.STATISTICS::X)) LH.STATISTICS::X
;          LH.STATISTICS::GLN))
;      LH.STATISTICS::G)
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*

; in: DEFUN GAMMA-LN
;     (<= LH.STATISTICS::X 0)
; 
; 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.

;     (> LH.STATISTICS::X 1.0d302)
; 
; note: unable to open-code RATIONAL to FLOAT comparison due to type uncertainty: The first argument is a (REAL (0)), not a RATIONAL.

;     (= LH.STATISTICS::X 0.5d0)
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to open-code RATIONAL to FLOAT comparison due to type uncertainty: The first argument is a (OR (RATIONAL (0) 100000000000000007629703079084894925347346855150656811701601734206211380288125794484142188964691784076639747577138548761372210387844799938291815611350519830750167649856488981626536368095414607314235151058373458986890825155659063617715863205282622390509284183439858617103083735673849899204570498157510656) (SINGLE-FLOAT (0.0)) (DOUBLE-FLOAT (0.0d0) 1.0d302)), not a RATIONAL.

;     (< LH.STATISTICS::X 1)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (RATIONAL (0) 100000000000000007629703079084894925347346855150656811701601734206211380288125794484142188964691784076639747577138548761372210387844799938291815611350519830750167649856488981626536368095414607314235151058373458986890825155659063617715863205282622390509284183439858617103083735673849899204570498157510656) (SINGLE-FLOAT (0.0)) (DOUBLE-FLOAT (0.0d0) 1.0d302)), not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (RATIONAL (0) 100000000000000007629703079084894925347346855150656811701601734206211380288125794484142188964691784076639747577138548761372210387844799938291815611350519830750167649856488981626536368095414607314235151058373458986890825155659063617715863205282622390509284183439858617103083735673849899204570498157510656) (SINGLE-FLOAT (0.0)) (DOUBLE-FLOAT (0.0d0) 1.0d302)), not a DOUBLE-FLOAT.

;     (LOG (SIN (* PI LH.STATISTICS:Z)))
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (DOUBLE-FLOAT * 0.0d0) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (LOG (* 2.50662827465d0 LH.STATISTICS::SER))
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (> LH.STATISTICS::X 1.0d302)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL (0)), not a DOUBLE-FLOAT.

;     (= LH.STATISTICS::X 0.5d0)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR (RATIONAL (0) 100000000000000007629703079084894925347346855150656811701601734206211380288125794484142188964691784076639747577138548761372210387844799938291815611350519830750167649856488981626536368095414607314235151058373458986890825155659063617715863205282622390509284183439858617103083735673849899204570498157510656) (SINGLE-FLOAT (0.0)) (DOUBLE-FLOAT (0.0d0) 1.0d302)), not a DOUBLE-FLOAT.

;     (< LH.STATISTICS::X 1)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a (OR (RATIONAL (0) 100000000000000007629703079084894925347346855150656811701601734206211380288125794484142188964691784076639747577138548761372210387844799938291815611350519830750167649856488981626536368095414607314235151058373458986890825155659063617715863205282622390509284183439858617103083735673849899204570498157510656) (SINGLE-FLOAT (0.0)) (DOUBLE-FLOAT (0.0d0) 1.0d302)), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (OR (RATIONAL (0) 100000000000000007629703079084894925347346855150656811701601734206211380288125794484142188964691784076639747577138548761372210387844799938291815611350519830750167649856488981626536368095414607314235151058373458986890825155659063617715863205282622390509284183439858617103083735673849899204570498157510656) (SINGLE-FLOAT (0.0)) (DOUBLE-FLOAT (0.0d0) 1.0d302)), not a FIXNUM.
;       etc.

;     (- 1.0d0 LH.STATISTICS::X)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a (REAL (0) (1)), not a SINGLE-FLOAT.

;     (+ (LH.STATISTICS::GAMMA-LN (+ 1.0 LH.STATISTICS:Z))
;        (LOG (SIN (* PI LH.STATISTICS:Z))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR (DOUBLE-FLOAT * 0.0d0) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR (DOUBLE-FLOAT * 0.0d0) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (- (+ (LOG LH.STATISTICS:Z) (LOG PI))
;        (+ (LH.STATISTICS::GAMMA-LN (+ 1.0 LH.STATISTICS:Z))
;           (LOG (SIN (* PI LH.STATISTICS:Z)))))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (- LH.STATISTICS::X 1.0d0)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a (OR (RATIONAL 1 100000000000000007629703079084894925347346855150656811701601734206211380288125794484142188964691784076639747577138548761372210387844799938291815611350519830750167649856488981626536368095414607314235151058373458986890825155659063617715863205282622390509284183439858617103083735673849899204570498157510656) (SINGLE-FLOAT 1.0) (DOUBLE-FLOAT 1.0d0 1.0d302)), not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (OR (RATIONAL 1 100000000000000007629703079084894925347346855150656811701601734206211380288125794484142188964691784076639747577138548761372210387844799938291815611350519830750167649856488981626536368095414607314235151058373458986890825155659063617715863205282622390509284183439858617103083735673849899204570498157510656) (SINGLE-FLOAT 1.0) (DOUBLE-FLOAT 1.0d0 1.0d302)), not a (SIGNED-BYTE 64).

;     (- (LOG (* 2.50662827465d0 LH.STATISTICS::SER)) LH.STATISTICS::TMP)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (LOG (* 2.50662827465d0 LH.STATISTICS::SER))
; 
; note: doing float to pointer coercion (cost 13)

;     (- (LOG (* 2.50662827465d0 LH.STATISTICS::SER)) LH.STATISTICS::TMP)
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC--

;     (LH.STATISTICS::GAMMA-LN (+ 1.0 LH.STATISTICS:Z))
; 
; note: doing float to pointer coercion (cost 13) to X

;     (SIN (* PI LH.STATISTICS:Z))
; 
; note: doing float to pointer coercion (cost 13)

;     (- (+ (LOG LH.STATISTICS:Z) (LOG PI))
;        (+ (LH.STATISTICS::GAMMA-LN (+ 1.0 LH.STATISTICS:Z))
;           (LOG (SIN (* PI LH.STATISTICS:Z)))))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first argument of GENERIC--

; in: DEFUN ERROR-FUNCTION-COMPLEMENT
;     (ABS LH.STATISTICS::X)
; 
; 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.
; 
; note: forced to do full call
;       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 &OPTIONAL).
;       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 &OPTIONAL).

;     (DEFUN LH.STATISTICS::ERROR-FUNCTION-COMPLEMENT (LH.STATISTICS::X)
;       "Adopted from CLASP 1.4.3, http://eksl-www.cs.umass.edu/clasp.html"
;       (LET* ((LH.STATISTICS:Z (ABS LH.STATISTICS::X))
;              (LH.STATISTICS::Y (/ 1.0d0 #))
;              (LH.STATISTICS::ANS (* LH.STATISTICS::Y #)))
;         (DECLARE
;          (TYPE DOUBLE-FLOAT LH.STATISTICS:Z LH.STATISTICS::Y LH.STATISTICS::ANS))
;         (IF (>= LH.STATISTICS::X 0.0)
;             LH.STATISTICS::ANS
;             (- 2.0 LH.STATISTICS::ANS))))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA LH.STATISTICS::ERROR-FUNCTION-COMPLEMENT
;         (LH.STATISTICS::X)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       "Adopted from CLASP 1.4.3, http://eksl-www.cs.umass.edu/clasp.html"
;       (BLOCK LH.STATISTICS::ERROR-FUNCTION-COMPLEMENT
;         (LET* ((LH.STATISTICS:Z #) (LH.STATISTICS::Y #) (LH.STATISTICS::ANS #))
;           (DECLARE
;            (TYPE DOUBLE-FLOAT LH.STATISTICS:Z LH.STATISTICS::Y
;             LH.STATISTICS::ANS))
;           (IF (>= LH.STATISTICS::X 0.0)
;               LH.STATISTICS::ANS
;               (- 2.0 LH.STATISTICS::ANS)))))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; in: DEFUN FIND-CRITICAL-VALUE
;     (FUNCALL LH.STATISTICS::P-FUNCTION LH.STATISTICS::X-HIGH)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: P-FUNCTION is not known to be a function

;     (>= LH.STATISTICS::FX-LOW LH.STATISTICS::P-VALUE LH.STATISTICS::FX-HIGH)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The second argument is a REAL, not a RATIONAL.

;     (FUNCALL LH.STATISTICS::P-FUNCTION LH.STATISTICS::X-MID)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: P-FUNCTION is not known to be a function

;     (ABS (- LH.STATISTICS::FX-MID LH.STATISTICS::P-VALUE))
; 
; 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.

;     (< LH.STATISTICS::X-DIFF LH.STATISTICS::X-TOLERANCE)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The second argument is a REAL, not a RATIONAL.

;     (< LH.STATISTICS::Y-DIFF LH.STATISTICS::Y-TOLERANCE)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0), not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0), not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.

;     (< LH.STATISTICS::P-VALUE LH.STATISTICS::FX-MID)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.

;     (FUNCALL LH.STATISTICS::P-FUNCTION LH.STATISTICS::X-HIGH)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: P-FUNCTION is not known to be a function

;     (COERCE (FUNCALL LH.STATISTICS::P-FUNCTION LH.STATISTICS::X-HIGH)
;             '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).

;     (>= LH.STATISTICS::FX-LOW LH.STATISTICS::P-VALUE LH.STATISTICS::FX-HIGH)
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The second argument is a T, not a DOUBLE-FLOAT.
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.

;     (- LH.STATISTICS::FX-MID LH.STATISTICS::P-VALUE)
; 
; 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 REAL, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

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

;     (< LH.STATISTICS::X-DIFF LH.STATISTICS::X-TOLERANCE)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The second argument is a T, not a DOUBLE-FLOAT.

;     (< LH.STATISTICS::Y-DIFF LH.STATISTICS::Y-TOLERANCE)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL 0), not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       etc.

;     (< LH.STATISTICS::P-VALUE LH.STATISTICS::FX-MID)
; 
; 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 NUMBER, 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 NUMBER, not a DOUBLE-FLOAT.
;       etc.

;     (LET* ((LH.STATISTICS::X-LOW 0.0d0)
;            (LH.STATISTICS::FX-LOW 1.0d0)
;            (LH.STATISTICS::X-HIGH 1.0d0)
;            (LH.STATISTICS::FX-HIGH
;             (COERCE (FUNCALL LH.STATISTICS::P-FUNCTION LH.STATISTICS::X-HIGH)
;                     'DOUBLE-FLOAT)))
;       (DECLARE
;        (TYPE DOUBLE-FLOAT LH.STATISTICS::X-LOW LH.STATISTICS::FX-LOW
;         LH.STATISTICS::X-HIGH LH.STATISTICS::FX-HIGH))
;       (DO ()
;           (NIL)
;         (WHEN
;             (>= LH.STATISTICS::FX-LOW LH.STATISTICS::P-VALUE
;                 LH.STATISTICS::FX-HIGH)
;           (RETURN))
;         (SETF LH.STATISTICS::X-LOW LH.STATISTICS::X-HIGH
;               LH.STATISTICS::FX-LOW LH.STATISTICS::FX-HIGH
;               LH.STATISTICS::X-HIGH (* 2.0 LH.STATISTICS::X-HIGH)
;               LH.STATISTICS::FX-HIGH
;                 (FUNCALL LH.STATISTICS::P-FUNCTION LH.STATISTICS::X-HIGH)))
;       (DO ()
;           (NIL)
;         (LET* ((LH.STATISTICS::X-MID #)
;                (LH.STATISTICS::FX-MID #)
;                (LH.STATISTICS::Y-DIFF #)
;                (LH.STATISTICS::X-DIFF #))
;           (WHEN (OR # #)
;             (RETURN-FROM LH.STATISTICS::FIND-CRITICAL-VALUE
;               LH.STATISTICS::X-MID))
;           (IF (< LH.STATISTICS::P-VALUE LH.STATISTICS::FX-MID)
;               (SETF #)
;               (SETF #)))))
; 
; note: doing float to pointer coercion (cost 13) to FX-HIGH

;     (SETF LH.STATISTICS::X-LOW LH.STATISTICS::X-HIGH
;           LH.STATISTICS::FX-LOW LH.STATISTICS::FX-HIGH
;           LH.STATISTICS::X-HIGH (* 2.0 LH.STATISTICS::X-HIGH)
;           LH.STATISTICS::FX-HIGH
;             (FUNCALL LH.STATISTICS::P-FUNCTION LH.STATISTICS::X-HIGH))
; --> SETF 
; ==>
;   (SETQ LH.STATISTICS::X-HIGH (* 2.0 LH.STATISTICS::X-HIGH))
; 
; note: doing float to pointer coercion (cost 13) to X-HIGH

;     (/ (+ LH.STATISTICS::X-LOW LH.STATISTICS::X-HIGH) 2.0)
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first result of inline float arithmetic

;     (< LH.STATISTICS::X-DIFF LH.STATISTICS::X-TOLERANCE)
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first argument of GENERIC-<

; in: DEFUN BETA-INCOMPLETE
;     (EXP
;      (+ (LH.STATISTICS::GAMMA-LN (+ LH.STATISTICS::A LH.STATISTICS::B))
;         (- (LH.STATISTICS::GAMMA-LN LH.STATISTICS::A))
;         (- (LH.STATISTICS::GAMMA-LN LH.STATISTICS::B))
;         (* LH.STATISTICS::A (LOG LH.STATISTICS::X))
;         (* LH.STATISTICS::B (LOG (- 1.0d0 LH.STATISTICS::X)))))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.

;     (COERCE LH.STATISTICS::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).

;     (COERCE LH.STATISTICS::B '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).

;     (COERCE LH.STATISTICS::X '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).

;     (+ (LH.STATISTICS::GAMMA-LN (+ LH.STATISTICS::A LH.STATISTICS::B))
;        (- (LH.STATISTICS::GAMMA-LN LH.STATISTICS::A))
;        (- (LH.STATISTICS::GAMMA-LN LH.STATISTICS::B))
;        (* LH.STATISTICS::A (LOG LH.STATISTICS::X))
;        (* LH.STATISTICS::B (LOG (- 1.0d0 LH.STATISTICS::X))))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* LH.STATISTICS::BT
;        (LH.STATISTICS::BETACF LH.STATISTICS::B LH.STATISTICS::A
;         (- 1.0d0 LH.STATISTICS::X)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (/
;      (* LH.STATISTICS::BT
;         (LH.STATISTICS::BETACF LH.STATISTICS::B LH.STATISTICS::A
;          (- 1.0d0 LH.STATISTICS::X)))
;      LH.STATISTICS::B)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (- 1.0d0
;        (/
;         (* LH.STATISTICS::BT
;            (LH.STATISTICS::BETACF LH.STATISTICS::B LH.STATISTICS::A
;             (- 1.0d0 LH.STATISTICS::X)))
;         LH.STATISTICS::B))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* LH.STATISTICS::BT
;        (LH.STATISTICS::BETACF LH.STATISTICS::A LH.STATISTICS::B LH.STATISTICS::X))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (/
;      (* LH.STATISTICS::BT
;         (LH.STATISTICS::BETACF LH.STATISTICS::A LH.STATISTICS::B
;          LH.STATISTICS::X))
;      LH.STATISTICS::A)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (SETQ LH.STATISTICS::A (COERCE LH.STATISTICS::A 'DOUBLE-FLOAT)
;           LH.STATISTICS::B (COERCE LH.STATISTICS::B 'DOUBLE-FLOAT)
;           LH.STATISTICS::X (COERCE LH.STATISTICS::X 'DOUBLE-FLOAT))
; 
; note: doing float to pointer coercion (cost 13) to A
; 
; note: doing float to pointer coercion (cost 13) to B
; 
; note: doing float to pointer coercion (cost 13) to X

;     (LH.STATISTICS::GAMMA-LN (+ LH.STATISTICS::A LH.STATISTICS::B))
; 
; note: doing float to pointer coercion (cost 13)

;     (+ (LH.STATISTICS::GAMMA-LN (+ LH.STATISTICS::A LH.STATISTICS::B))
;        (- (LH.STATISTICS::GAMMA-LN LH.STATISTICS::A))
;        (- (LH.STATISTICS::GAMMA-LN LH.STATISTICS::B))
;        (* LH.STATISTICS::A (LOG LH.STATISTICS::X))
;        (* LH.STATISTICS::B (LOG (- 1.0d0 LH.STATISTICS::X))))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-+
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-+

;     (LH.STATISTICS::BETACF (LH.STATISTICS::A LH.STATISTICS::B LH.STATISTICS::X)
;      (DECLARE
;       (TYPE DOUBLE-FLOAT LH.STATISTICS::A LH.STATISTICS::B LH.STATISTICS::X))
;      (LET ((LH.STATISTICS::ITMAX 1000)
;            (LH.STATISTICS::EPS 3.0d-7)
;            (LH.STATISTICS::QAP 0.0d0)
;            (LH.STATISTICS::QAM 0.0d0)
;            (LH.STATISTICS::QAB 0.0d0)
;            (LH.STATISTICS::EM 0.0d0)
;            (LH.STATISTICS::TEM 0.0d0)
;            (LH.STATISTICS::D 0.0d0)
;            (LH.STATISTICS::BZ 0.0d0)
;            (LH.STATISTICS::BM 1.0d0)
;            (LH.STATISTICS::BP 0.0d0)
;            (LH.STATISTICS::BPP 0.0d0)
;            ...)
;        (DECLARE
;         (TYPE DOUBLE-FLOAT LH.STATISTICS::QAP LH.STATISTICS::QAM
;          LH.STATISTICS::QAB LH.STATISTICS::TEM LH.STATISTICS::D LH.STATISTICS::BZ
;          LH.STATISTICS::BM LH.STATISTICS::BP LH.STATISTICS::BPP LH.STATISTICS::AZ
;          ...))
;        (SETF LH.STATISTICS::QAB (+ LH.STATISTICS::A LH.STATISTICS::B)
;              LH.STATISTICS::QAP (+ LH.STATISTICS::A 1.0d0)
;              LH.STATISTICS::QAM (- LH.STATISTICS::A 1.0d0)
;              LH.STATISTICS::BZ (- 1.0d0 #))
;        (DOTIMES (LH.STATISTICS::M LH.STATISTICS::ITMAX)
;          (SETF LH.STATISTICS::EM #)
;          (SETF LH.STATISTICS::TEM #
;                LH.STATISTICS::D #
;                LH.STATISTICS::AP #
;                LH.STATISTICS::BP #
;                LH.STATISTICS::D #
;                LH.STATISTICS::APP #
;                ...)
;          (IF (< # #)
;              (RETURN-FROM LH.STATISTICS::BETACF LH.STATISTICS::AZ)))
;        (ERROR "a=~s or b=~s too big, or ITMAX too small in BETACF"
;               LH.STATISTICS::A LH.STATISTICS::B)))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; in: DEFUN SAFE-EXP
;     (COERCE LH.STATISTICS::X '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).

;     (SETF LH.STATISTICS::X (COERCE LH.STATISTICS::X 'DOUBLE-FLOAT))
; 
; note: doing float to pointer coercion (cost 13) to X

;     (EXP LH.STATISTICS::X)
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/statistics/dd4153c8e73ae8b85ed2082b488eb18214ff0bd9/statistics-20250828-git/ls-statistics.lisp
; in: DEFUN VARIANCE
;     (LS.STATISTICS::BIASED? NIL)
; 
; caught STYLE-WARNING:
;   The variable BIASED? is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "statistics" "ls-statistics">
WARNING: redefining UIOP/PACKAGE:FIND-PACKAGE* in DEFUN
WARNING: redefining UIOP/PACKAGE:FIND-SYMBOL* in DEFUN
WARNING: redefining UIOP/PACKAGE:SYMBOL-CALL in DEFUN
WARNING: redefining UIOP/PACKAGE:INTERN* in DEFUN
WARNING: redefining UIOP/PACKAGE:EXPORT* in DEFUN
WARNING: redefining UIOP/PACKAGE:IMPORT* in DEFUN
WARNING: redefining UIOP/PACKAGE:SHADOWING-IMPORT* in DEFUN
WARNING: redefining UIOP/PACKAGE:SHADOW* in DEFUN
WARNING: redefining UIOP/PACKAGE:MAKE-SYMBOL* in DEFUN
WARNING: redefining UIOP/PACKAGE:UNINTERN* in DEFUN
WARNING: redefining UIOP/PACKAGE:SYMBOL-SHADOWING-P in DEFUN
WARNING: redefining UIOP/PACKAGE:HOME-PACKAGE-P in DEFUN
WARNING: redefining UIOP/PACKAGE:SYMBOL-PACKAGE-NAME in DEFUN
WARNING: redefining UIOP/PACKAGE:STANDARD-COMMON-LISP-SYMBOL-P in DEFUN
WARNING: redefining UIOP/PACKAGE:REIFY-PACKAGE in DEFUN
WARNING: redefining UIOP/PACKAGE:UNREIFY-PACKAGE in DEFUN
WARNING: redefining UIOP/PACKAGE:REIFY-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE:UNREIFY-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE::RECORD-FISHY in DEFUN
WARNING: redefining UIOP/PACKAGE::WHEN-PACKAGE-FISHINESS in DEFMACRO
WARNING: redefining UIOP/PACKAGE::NOTE-PACKAGE-FISHINESS in DEFMACRO
WARNING: redefining UIOP/PACKAGE::SET-DUMMY-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE::MAKE-DUMMY-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE::DUMMY-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE::GET-DUMMY-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE:NUKE-SYMBOL-IN-PACKAGE in DEFUN
WARNING: redefining UIOP/PACKAGE:NUKE-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE:REHOME-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE:ENSURE-PACKAGE-UNUSED in DEFUN
WARNING: redefining UIOP/PACKAGE:DELETE-PACKAGE* in DEFUN
WARNING: redefining UIOP/PACKAGE:PACKAGE-NAMES in DEFUN
WARNING: redefining UIOP/PACKAGE:PACKAGES-FROM-NAMES in DEFUN
WARNING: redefining UIOP/PACKAGE:FRESH-PACKAGE-NAME in DEFUN
WARNING: redefining UIOP/PACKAGE:RENAME-PACKAGE-AWAY in DEFUN
WARNING: redefining UIOP/PACKAGE:PACKAGE-DEFINITION-FORM in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-SHADOWING-IMPORT in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-IMPORTED in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-IMPORT in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-INHERITED in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-MIX in DEFUN
WARNING: redefining UIOP/PACKAGE::RECYCLE-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE::SYMBOL-RECYCLED-P in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-EXPORTED-TO-USER in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-EXPORTED in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-EXPORT in DEFUN
WARNING: redefining UIOP/PACKAGE::INSTALL-PACKAGE-LOCAL-NICKNAMES in DEFUN
WARNING: redefining UIOP/PACKAGE:ENSURE-PACKAGE in DEFUN
WARNING: redefining UIOP/PACKAGE:PARSE-DEFINE-PACKAGE-FORM in DEFUN
WARNING: redefining UIOP/PACKAGE:DEFINE-PACKAGE in DEFMACRO
WARNING: redefining UIOP/COMMON-LISP::FROB-SUBSTRINGS in DEFUN
WARNING: redefining UIOP/COMMON-LISP::COMPATFMT in DEFMACRO
WARNING: redefining UIOP/UTILITY::ENSURE-FUNCTION-NOTINLINE in DEFUN
WARNING: redefining UIOP/UTILITY:WITH-UPGRADABILITY in DEFMACRO
WARNING: redefining UIOP/UTILITY:UIOP-DEBUG in DEFMACRO
WARNING: redefining UIOP/UTILITY:LOAD-UIOP-DEBUG-UTILITY in DEFUN
WARNING: redefining UIOP/UTILITY:NEST in DEFMACRO
WARNING: redefining UIOP/UTILITY:IF-LET in DEFMACRO
WARNING: redefining UIOP/UTILITY:PARSE-BODY in DEFUN
WARNING: redefining UIOP/UTILITY:WHILE-COLLECTING in DEFMACRO
WARNING: redefining UIOP/UTILITY:APPENDF in DEFMACRO
WARNING: redefining UIOP/UTILITY:LENGTH=N-P in DEFUN
WARNING: redefining UIOP/UTILITY:ENSURE-LIST in DEFUN
WARNING: redefining UIOP/UTILITY:REMOVE-PLIST-KEY in DEFUN
WARNING: redefining UIOP/UTILITY:REMOVE-PLIST-KEYS in DEFUN
WARNING: redefining UIOP/UTILITY:EMPTYP in DEFUN
WARNING: redefining UIOP/UTILITY:CHARACTER-TYPE-INDEX in DEFUN
WARNING: redefining UIOP/UTILITY:BASE-STRING-P in DEFUN
WARNING: redefining UIOP/UTILITY:STRINGS-COMMON-ELEMENT-TYPE in DEFUN
WARNING: redefining UIOP/UTILITY:REDUCE/STRCAT in DEFUN
WARNING: redefining UIOP/UTILITY:STRCAT in DEFUN
WARNING: redefining UIOP/UTILITY:FIRST-CHAR in DEFUN
WARNING: redefining UIOP/UTILITY:LAST-CHAR in DEFUN
WARNING: redefining UIOP/UTILITY:SPLIT-STRING in DEFUN
WARNING: redefining UIOP/UTILITY:STRING-PREFIX-P in DEFUN
WARNING: redefining UIOP/UTILITY:STRING-SUFFIX-P in DEFUN
WARNING: redefining UIOP/UTILITY:STRING-ENCLOSED-P in DEFUN
WARNING: redefining UIOP/UTILITY:STRIPLN in DEFUN
WARNING: redefining UIOP/UTILITY:STANDARD-CASE-SYMBOL-NAME in DEFUN
WARNING: redefining UIOP/UTILITY:FIND-STANDARD-CASE-SYMBOL in DEFUN
WARNING: redefining UIOP/UTILITY:TIMESTAMP< in DEFUN
WARNING: redefining UIOP/UTILITY:TIMESTAMPS< in DEFUN
WARNING: redefining UIOP/UTILITY:TIMESTAMP*< in DEFUN
WARNING: redefining UIOP/UTILITY:TIMESTAMP<= in DEFUN
WARNING: redefining UIOP/UTILITY:EARLIER-TIMESTAMP in DEFUN
WARNING: redefining UIOP/UTILITY:TIMESTAMPS-EARLIEST in DEFUN
WARNING: redefining UIOP/UTILITY:EARLIEST-TIMESTAMP in DEFUN
WARNING: redefining UIOP/UTILITY:LATER-TIMESTAMP in DEFUN
WARNING: redefining UIOP/UTILITY:TIMESTAMPS-LATEST in DEFUN
WARNING: redefining UIOP/UTILITY:LATEST-TIMESTAMP in DEFUN
WARNING: redefining UIOP/UTILITY:LATEST-TIMESTAMP-F in DEFMACRO
WARNING: redefining UIOP/UTILITY:ENSURE-FUNCTION in DEFUN
WARNING: redefining UIOP/UTILITY:ACCESS-AT in DEFUN
WARNING: redefining UIOP/UTILITY:ACCESS-AT-COUNT in DEFUN
WARNING: redefining UIOP/UTILITY:CALL-FUNCTION in DEFUN
WARNING: redefining UIOP/UTILITY:CALL-FUNCTIONS in DEFUN
WARNING: redefining UIOP/UTILITY:REGISTER-HOOK-FUNCTION in DEFUN
WARNING: redefining UIOP/UTILITY:COERCE-CLASS in DEFUN
WARNING: redefining UIOP/UTILITY:ENSURE-GETHASH in DEFUN
WARNING: redefining UIOP/UTILITY:LIST-TO-HASH-SET in DEFUN
WARNING: redefining UIOP/UTILITY:LEXICOGRAPHIC< in DEFUN
WARNING: redefining UIOP/UTILITY:LEXICOGRAPHIC<= in DEFUN
WARNING: redefining UIOP/UTILITY:STYLE-WARN in DEFUN
WARNING: redefining UIOP/UTILITY:MATCH-CONDITION-P in DEFUN
WARNING: redefining UIOP/UTILITY:MATCH-ANY-CONDITION-P in DEFUN
WARNING: redefining UIOP/UTILITY:CALL-WITH-MUFFLED-CONDITIONS in DEFUN
WARNING: redefining UIOP/UTILITY:WITH-MUFFLED-CONDITIONS in DEFMACRO
WARNING: redefining UIOP/UTILITY:NOT-IMPLEMENTED-ERROR in DEFUN
WARNING: redefining UIOP/UTILITY:PARAMETER-ERROR in DEFUN
WARNING: redefining UIOP/UTILITY:BOOLEAN-TO-FEATURE-EXPRESSION in DEFUN
WARNING: redefining UIOP/UTILITY:SYMBOL-TEST-TO-FEATURE-EXPRESSION in DEFUN
WARNING: redefining UIOP/VERSION:UNPARSE-VERSION in DEFUN
WARNING: redefining UIOP/VERSION:PARSE-VERSION in DEFUN
WARNING: redefining UIOP/VERSION:NEXT-VERSION in DEFUN
WARNING: redefining UIOP/VERSION:VERSION< in DEFUN
WARNING: redefining UIOP/VERSION:VERSION<= in DEFUN
WARNING: redefining UIOP/VERSION::DEPRECATED-FUNCTION-CONDITION-KIND in DEFUN
WARNING: redefining PRINT-OBJECT (#<SB-PCL::CONDITION-CLASS UIOP/VERSION:DEPRECATED-FUNCTION-CONDITION> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining UIOP/VERSION::NOTIFY-DEPRECATED-FUNCTION in DEFUN
WARNING: redefining UIOP/VERSION:VERSION-DEPRECATION in DEFUN
WARNING: redefining UIOP/VERSION:WITH-DEPRECATION in DEFMACRO
WARNING: redefining UIOP/OS:FEATUREP in DEFUN
WARNING: redefining UIOP/OS:OS-MACOSX-P in DEFUN
WARNING: redefining UIOP/OS:OS-UNIX-P in DEFUN
WARNING: redefining UIOP/OS:OS-WINDOWS-P in DEFUN
WARNING: redefining UIOP/OS:OS-GENERA-P in DEFUN
WARNING: redefining UIOP/OS::OS-OLDMAC-P in DEFUN
WARNING: redefining UIOP/OS::OS-HAIKU-P in DEFUN
WARNING: redefining UIOP/OS::OS-MEZZANO-P in DEFUN
WARNING: redefining UIOP/OS:DETECT-OS in DEFUN
WARNING: redefining UIOP/OS:OS-COND in DEFMACRO
WARNING: redefining UIOP/OS:GETENV in DEFUN
WARNING: redefining UIOP/OS:GETENVP in DEFUN
WARNING: redefining UIOP/OS::FIRST-FEATURE in DEFUN
WARNING: redefining UIOP/OS:IMPLEMENTATION-TYPE in DEFUN
WARNING: redefining UIOP/OS:OPERATING-SYSTEM in DEFUN
WARNING: redefining UIOP/OS:ARCHITECTURE in DEFUN
WARNING: redefining UIOP/OS:LISP-VERSION-STRING in DEFUN
WARNING: redefining UIOP/OS:IMPLEMENTATION-IDENTIFIER in DEFUN
WARNING: redefining UIOP/OS:HOSTNAME in DEFUN
WARNING: redefining UIOP/OS:GETCWD in DEFUN
WARNING: redefining UIOP/OS:CHDIR in DEFUN
WARNING: redefining UIOP/OS:READ-NULL-TERMINATED-STRING in DEFUN
WARNING: redefining UIOP/OS:READ-LITTLE-ENDIAN in DEFUN
WARNING: redefining UIOP/OS:PARSE-FILE-LOCATION-INFO in DEFUN
WARNING: redefining UIOP/OS:PARSE-WINDOWS-SHORTCUT in DEFUN
WARNING: redefining UIOP/PATHNAME:NORMALIZE-PATHNAME-DIRECTORY-COMPONENT in DEFUN
WARNING: redefining UIOP/PATHNAME:DENORMALIZE-PATHNAME-DIRECTORY-COMPONENT in DEFUN
WARNING: redefining UIOP/PATHNAME:MERGE-PATHNAME-DIRECTORY-COMPONENTS in DEFUN
WARNING: redefining UIOP/PATHNAME:MAKE-PATHNAME* in DEFUN
WARNING: redefining UIOP/PATHNAME:MAKE-PATHNAME-COMPONENT-LOGICAL in DEFUN
WARNING: redefining UIOP/PATHNAME:MAKE-PATHNAME-LOGICAL in DEFUN
WARNING: redefining UIOP/PATHNAME:MERGE-PATHNAMES* in DEFUN
WARNING: redefining UIOP/PATHNAME:LOGICAL-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:PHYSICAL-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:PHYSICALIZE-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:NIL-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:WITH-PATHNAME-DEFAULTS in DEFMACRO
WARNING: redefining UIOP/PATHNAME:PATHNAME-EQUAL in DEFUN
WARNING: redefining UIOP/PATHNAME:ABSOLUTE-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:RELATIVE-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:HIDDEN-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:FILE-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:PATHNAME-DIRECTORY-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:PATHNAME-PARENT-DIRECTORY-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:DIRECTORY-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:ENSURE-DIRECTORY-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:SPLIT-UNIX-NAMESTRING-DIRECTORY-COMPONENTS in DEFUN
WARNING: redefining UIOP/PATHNAME:SPLIT-NAME-TYPE in DEFUN
WARNING: redefining UIOP/PATHNAME:PARSE-UNIX-NAMESTRING in DEFUN
WARNING: redefining UIOP/PATHNAME:UNIX-NAMESTRING in DEFUN
WARNING: redefining UIOP/PATHNAME:SUBPATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:SUBPATHNAME* in DEFUN
WARNING: redefining UIOP/PATHNAME:PATHNAME-ROOT in DEFUN
WARNING: redefining UIOP/PATHNAME:PATHNAME-HOST-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:ENSURE-ABSOLUTE-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:SUBPATHP in DEFUN
WARNING: redefining UIOP/PATHNAME:ENOUGH-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:CALL-WITH-ENOUGH-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:WITH-ENOUGH-PATHNAME in DEFMACRO
WARNING: redefining UIOP/PATHNAME:WILDEN in DEFUN
WARNING: redefining UIOP/PATHNAME:RELATIVIZE-DIRECTORY-COMPONENT in DEFUN
WARNING: redefining UIOP/PATHNAME:RELATIVIZE-PATHNAME-DIRECTORY in DEFUN
WARNING: redefining UIOP/PATHNAME:DIRECTORY-SEPARATOR-FOR-HOST in DEFUN
WARNING: redefining UIOP/PATHNAME:DIRECTORIZE-PATHNAME-HOST-DEVICE in DEFUN
WARNING: redefining UIOP/PATHNAME:TRANSLATE-PATHNAME* in DEFUN
WARNING: redefining UIOP/FILESYSTEM:NATIVE-NAMESTRING in DEFUN
WARNING: redefining UIOP/FILESYSTEM:PARSE-NATIVE-NAMESTRING in DEFUN
WARNING: redefining UIOP/FILESYSTEM:TRUENAME* in DEFUN
WARNING: redefining UIOP/FILESYSTEM:SAFE-FILE-WRITE-DATE in DEFUN
WARNING: redefining UIOP/FILESYSTEM:PROBE-FILE* in DEFUN
WARNING: redefining UIOP/FILESYSTEM:DIRECTORY-EXISTS-P in DEFUN
WARNING: redefining UIOP/FILESYSTEM:FILE-EXISTS-P in DEFUN
WARNING: redefining UIOP/FILESYSTEM:DIRECTORY* in DEFUN
WARNING: redefining UIOP/FILESYSTEM:FILTER-LOGICAL-DIRECTORY-RESULTS in DEFUN
WARNING: redefining UIOP/FILESYSTEM:DIRECTORY-FILES in DEFUN
WARNING: redefining UIOP/FILESYSTEM:SUBDIRECTORIES in DEFUN
WARNING: redefining UIOP/FILESYSTEM:COLLECT-SUB*DIRECTORIES in DEFUN
WARNING: redefining UIOP/FILESYSTEM:TRUENAMIZE in DEFUN
WARNING: redefining UIOP/FILESYSTEM:RESOLVE-SYMLINKS in DEFUN
WARNING: redefining UIOP/FILESYSTEM:RESOLVE-SYMLINKS* in DEFUN
WARNING: redefining UIOP/PATHNAME:ENSURE-PATHNAME in DEFUN
WARNING: redefining UIOP/FILESYSTEM:GET-PATHNAME-DEFAULTS in DEFUN
WARNING: redefining UIOP/FILESYSTEM:CALL-WITH-CURRENT-DIRECTORY in DEFUN
WARNING: redefining UIOP/FILESYSTEM:WITH-CURRENT-DIRECTORY in DEFMACRO
WARNING: redefining UIOP/FILESYSTEM:INTER-DIRECTORY-SEPARATOR in DEFUN
WARNING: redefining UIOP/FILESYSTEM:SPLIT-NATIVE-PATHNAMES-STRING in DEFUN
WARNING: redefining UIOP/FILESYSTEM:GETENV-PATHNAME in DEFUN
WARNING: redefining UIOP/FILESYSTEM:GETENV-PATHNAMES in DEFUN
WARNING: redefining UIOP/FILESYSTEM:GETENV-ABSOLUTE-DIRECTORY in DEFUN
WARNING: redefining UIOP/FILESYSTEM:GETENV-ABSOLUTE-DIRECTORIES in DEFUN
WARNING: redefining UIOP/FILESYSTEM:LISP-IMPLEMENTATION-DIRECTORY in DEFUN
WARNING: redefining UIOP/FILESYSTEM:LISP-IMPLEMENTATION-PATHNAME-P in DEFUN
WARNING: redefining UIOP/FILESYSTEM:ENSURE-ALL-DIRECTORIES-EXIST in DEFUN
WARNING: redefining UIOP/FILESYSTEM:DELETE-FILE-IF-EXISTS in DEFUN
WARNING: redefining UIOP/FILESYSTEM:RENAME-FILE-OVERWRITING-TARGET in DEFUN
WARNING: redefining UIOP/FILESYSTEM:DELETE-EMPTY-DIRECTORY in DEFUN
WARNING: redefining UIOP/FILESYSTEM:DELETE-DIRECTORY-TREE in DEFUN
WARNING: redefining UIOP/STREAM:SETUP-STDIN in DEFUN
WARNING: redefining UIOP/STREAM:SETUP-STDOUT in DEFUN
WARNING: redefining UIOP/STREAM:SETUP-STDERR in DEFUN
WARNING: redefining UIOP/STREAM:ALWAYS-DEFAULT-ENCODING in DEFUN
WARNING: redefining UIOP/STREAM:DETECT-ENCODING in DEFUN
WARNING: redefining UIOP/STREAM:DEFAULT-ENCODING-EXTERNAL-FORMAT in DEFUN
WARNING: redefining UIOP/STREAM:ENCODING-EXTERNAL-FORMAT in DEFUN
WARNING: redefining UIOP/STREAM:WITH-SAFE-IO-SYNTAX in DEFMACRO
WARNING: redefining UIOP/STREAM:CALL-WITH-SAFE-IO-SYNTAX in DEFUN
WARNING: redefining UIOP/STREAM:SAFE-READ-FROM-STRING in DEFUN
WARNING: redefining UIOP/STREAM:CALL-WITH-OUTPUT-FILE in DEFUN
WARNING: redefining UIOP/STREAM:WITH-OUTPUT-FILE in DEFMACRO
WARNING: redefining UIOP/STREAM::CALL-WITH-OUTPUT in DEFUN
WARNING: redefining UIOP/STREAM:OUTPUT-STRING in DEFUN
WARNING: redefining UIOP/STREAM:CALL-WITH-INPUT-FILE in DEFUN
WARNING: redefining UIOP/STREAM:WITH-INPUT-FILE in DEFMACRO
WARNING: redefining UIOP/STREAM::CALL-WITH-INPUT in DEFUN
WARNING: redefining UIOP/STREAM:WITH-INPUT in DEFMACRO
WARNING: redefining UIOP/STREAM:INPUT-STRING in DEFUN
WARNING: redefining UIOP/STREAM:NULL-DEVICE-PATHNAME in DEFUN
WARNING: redefining UIOP/STREAM:CALL-WITH-NULL-INPUT in DEFUN
WARNING: redefining UIOP/STREAM:WITH-NULL-INPUT in DEFMACRO
WARNING: redefining UIOP/STREAM:CALL-WITH-NULL-OUTPUT in DEFUN
WARNING: redefining UIOP/STREAM:WITH-NULL-OUTPUT in DEFMACRO
WARNING: redefining UIOP/STREAM:FINISH-OUTPUTS in DEFUN
WARNING: redefining UIOP/STREAM:FORMAT! in DEFUN
WARNING: redefining UIOP/STREAM:SAFE-FORMAT! in DEFUN
WARNING: redefining UIOP/STREAM:COPY-STREAM-TO-STREAM in DEFUN
WARNING: redefining UIOP/STREAM:CONCATENATE-FILES in DEFUN
WARNING: redefining UIOP/STREAM:COPY-FILE in DEFUN
WARNING: redefining UIOP/STREAM:SLURP-STREAM-STRING in DEFUN
WARNING: redefining UIOP/STREAM:SLURP-STREAM-LINES in DEFUN
WARNING: redefining UIOP/STREAM:SLURP-STREAM-LINE in DEFUN
WARNING: redefining UIOP/STREAM:SLURP-STREAM-FORMS in DEFUN
WARNING: redefining UIOP/STREAM:SLURP-STREAM-FORM in DEFUN
WARNING: redefining UIOP/STREAM:READ-FILE-STRING in DEFUN
WARNING: redefining UIOP/STREAM:READ-FILE-LINES in DEFUN
WARNING: redefining UIOP/STREAM:READ-FILE-LINE in DEFUN
WARNING: redefining UIOP/STREAM:READ-FILE-FORMS in DEFUN
WARNING: redefining UIOP/STREAM:READ-FILE-FORM in DEFUN
WARNING: redefining UIOP/STREAM:SAFE-READ-FILE-LINE in DEFUN
WARNING: redefining UIOP/STREAM:SAFE-READ-FILE-FORM in DEFUN
WARNING: redefining UIOP/STREAM:EVAL-INPUT in DEFUN
WARNING: redefining UIOP/STREAM:EVAL-THUNK in DEFUN
WARNING: redefining UIOP/STREAM:STANDARD-EVAL-THUNK in DEFUN
WARNING: redefining UIOP/STREAM:PRINTLN in DEFUN
WARNING: redefining UIOP/STREAM:WRITELN in DEFUN
WARNING: redefining UIOP/STREAM:DEFAULT-TEMPORARY-DIRECTORY in DEFUN
WARNING: redefining UIOP/STREAM:TEMPORARY-DIRECTORY in DEFUN
WARNING: redefining UIOP/STREAM:SETUP-TEMPORARY-DIRECTORY in DEFUN
WARNING: redefining UIOP/STREAM:CALL-WITH-TEMPORARY-FILE in DEFUN
WARNING: redefining UIOP/STREAM:WITH-TEMPORARY-FILE in DEFMACRO
WARNING: redefining UIOP/STREAM::GET-TEMPORARY-FILE in DEFUN
WARNING: redefining UIOP/STREAM:ADD-PATHNAME-SUFFIX in DEFUN
WARNING: redefining UIOP/STREAM:TMPIZE-PATHNAME in DEFUN
WARNING: redefining UIOP/STREAM:CALL-WITH-STAGING-PATHNAME in DEFUN
WARNING: redefining UIOP/STREAM:WITH-STAGING-PATHNAME in DEFMACRO
WARNING: redefining UIOP/STREAM:FILE-STREAM-P in DEFUN
WARNING: redefining UIOP/STREAM:FILE-OR-SYNONYM-STREAM-P in DEFUN
WARNING: redefining UIOP/IMAGE:QUIT in DEFUN
WARNING: redefining UIOP/IMAGE:DIE in DEFUN
WARNING: redefining UIOP/IMAGE:RAW-PRINT-BACKTRACE in DEFUN
WARNING: redefining UIOP/IMAGE:PRINT-BACKTRACE in DEFUN
WARNING: redefining UIOP/IMAGE:PRINT-CONDITION-BACKTRACE in DEFUN
WARNING: redefining UIOP/IMAGE:FATAL-CONDITION-P in DEFUN
WARNING: redefining UIOP/IMAGE:HANDLE-FATAL-CONDITION in DEFUN
WARNING: redefining UIOP/IMAGE:CALL-WITH-FATAL-CONDITION-HANDLER in DEFUN
WARNING: redefining UIOP/IMAGE:WITH-FATAL-CONDITION-HANDLER in DEFMACRO
WARNING: redefining UIOP/IMAGE:SHELL-BOOLEAN-EXIT in DEFUN
WARNING: redefining UIOP/IMAGE:REGISTER-IMAGE-RESTORE-HOOK in DEFUN
WARNING: redefining UIOP/IMAGE:REGISTER-IMAGE-DUMP-HOOK in DEFUN
WARNING: redefining UIOP/IMAGE:CALL-IMAGE-RESTORE-HOOK in DEFUN
WARNING: redefining UIOP/IMAGE:CALL-IMAGE-DUMP-HOOK in DEFUN
WARNING: redefining UIOP/IMAGE:RAW-COMMAND-LINE-ARGUMENTS in DEFUN
WARNING: redefining UIOP/IMAGE:COMMAND-LINE-ARGUMENTS in DEFUN
WARNING: redefining UIOP/IMAGE:ARGV0 in DEFUN
WARNING: redefining UIOP/IMAGE:SETUP-COMMAND-LINE-ARGUMENTS in DEFUN
WARNING: redefining UIOP/IMAGE:RESTORE-IMAGE in DEFUN
WARNING: redefining UIOP/IMAGE:DUMP-IMAGE in DEFUN
WARNING: redefining UIOP/IMAGE:CREATE-IMAGE in DEFUN
WARNING: redefining UIOP/LISP-BUILD::SB-GROVEL-UNKNOWN-CONSTANT-CONDITION-P in DEFUN
WARNING: redefining UIOP/LISP-BUILD:CALL-WITH-MUFFLED-COMPILER-CONDITIONS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:WITH-MUFFLED-COMPILER-CONDITIONS in DEFMACRO
WARNING: redefining UIOP/LISP-BUILD:CALL-WITH-MUFFLED-LOADER-CONDITIONS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:WITH-MUFFLED-LOADER-CONDITIONS in DEFMACRO
WARNING: redefining UIOP/LISP-BUILD:CHECK-LISP-COMPILE-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:CHECK-LISP-COMPILE-RESULTS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:REIFY-SIMPLE-SEXP in DEFUN
WARNING: redefining UIOP/LISP-BUILD:UNREIFY-SIMPLE-SEXP in DEFUN
WARNING: redefining UIOP/LISP-BUILD::REIFY-UNDEFINED-WARNING in DEFUN
WARNING: redefining UIOP/LISP-BUILD:REIFY-DEFERRED-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:UNREIFY-DEFERRED-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:RESET-DEFERRED-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:SAVE-DEFERRED-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:WARNINGS-FILE-TYPE in DEFUN
WARNING: redefining UIOP/LISP-BUILD:ENABLE-DEFERRED-WARNINGS-CHECK in DEFUN
WARNING: redefining UIOP/LISP-BUILD:DISABLE-DEFERRED-WARNINGS-CHECK in DEFUN
WARNING: redefining UIOP/LISP-BUILD:WARNINGS-FILE-P in DEFUN
WARNING: redefining UIOP/LISP-BUILD:CHECK-DEFERRED-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD::CALL-WITH-SAVED-DEFERRED-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:WITH-SAVED-DEFERRED-WARNINGS in DEFMACRO
WARNING: redefining UIOP/LISP-BUILD:CURRENT-LISP-FILE-PATHNAME in DEFUN
WARNING: redefining UIOP/LISP-BUILD:LOAD-PATHNAME in DEFUN
WARNING: redefining UIOP/LISP-BUILD:LISPIZE-PATHNAME in DEFUN
WARNING: redefining UIOP/LISP-BUILD:COMPILE-FILE-TYPE in DEFUN
WARNING: redefining UIOP/LISP-BUILD:CALL-AROUND-HOOK in DEFUN
WARNING: redefining UIOP/LISP-BUILD:COMPILE-FILE-PATHNAME* in DEFUN
WARNING: redefining UIOP/LISP-BUILD:COMPILE-FILE* in DEFUN
WARNING: redefining UIOP/LISP-BUILD:LOAD* in DEFUN
WARNING: redefining UIOP/LISP-BUILD:LOAD-FROM-STRING in DEFUN
WARNING: redefining UIOP/LISP-BUILD:COMBINE-FASLS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::REQUIRES-ESCAPING-P in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-TOKEN in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::ESCAPE-WINDOWS-TOKEN-WITHIN-DOUBLE-QUOTES in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::EASY-WINDOWS-CHARACTER-P in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-WINDOWS-TOKEN in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::ESCAPE-SH-TOKEN-WITHIN-DOUBLE-QUOTES in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:EASY-SH-CHARACTER-P in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-SH-TOKEN in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-SHELL-TOKEN in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-COMMAND in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-WINDOWS-COMMAND in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-SH-COMMAND in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-SHELL-COMMAND in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%NORMALIZE-IO-SPECIFIER in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%INTERACTIVEP in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%SIGNAL-TO-EXIT-CODE in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%CODE-TO-STATUS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%HANDLE-IF-EXISTS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%HANDLE-IF-DOES-NOT-EXIST in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:PROCESS-INFO-ERROR-OUTPUT in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:PROCESS-INFO-INPUT in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:PROCESS-INFO-OUTPUT in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:PROCESS-INFO-PID in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%PROCESS-STATUS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:PROCESS-ALIVE-P in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:WAIT-PROCESS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%POSIX-SEND-SIGNAL in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:TERMINATE-PROCESS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:CLOSE-STREAMS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:LAUNCH-PROGRAM in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::CALL-STREAM-PROCESSOR in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM:SLURP-INPUT-STREAM in DEFGENERIC
WARNING: redefining SLURP-INPUT-STREAM (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:FUNCTION> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:CONS> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:STREAM> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER STRING> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER :STRING> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER :LINES> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER :LINE> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER :FORMS> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER :FORM> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER T> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:NULL> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:PATHNAME> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:T> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining UIOP/RUN-PROGRAM:VOMIT-OUTPUT-STREAM in DEFGENERIC
WARNING: redefining VOMIT-OUTPUT-STREAM (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:FUNCTION> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:CONS> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:STREAM> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:STRING> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER T> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:NULL> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:PATHNAME> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:T> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining UIOP/RUN-PROGRAM::%CHECK-RESULT in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%ACTIVE-IO-SPECIFIER-P in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%RUN-PROGRAM in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%CALL-WITH-PROGRAM-IO in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::PLACE-SETTER in DEFMACRO
WARNING: redefining UIOP/RUN-PROGRAM::WITH-PROGRAM-INPUT in DEFMACRO
WARNING: redefining UIOP/RUN-PROGRAM::WITH-PROGRAM-OUTPUT in DEFMACRO
WARNING: redefining UIOP/RUN-PROGRAM::WITH-PROGRAM-ERROR-OUTPUT in DEFMACRO
WARNING: redefining UIOP/RUN-PROGRAM::%USE-LAUNCH-PROGRAM in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%NORMALIZE-SYSTEM-COMMAND in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%REDIRECTED-SYSTEM-COMMAND in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%SYSTEM in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%USE-SYSTEM in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM:RUN-PROGRAM in DEFUN
WARNING: redefining UIOP/CONFIGURATION:CONFIGURATION-INHERITANCE-DIRECTIVE-P in DEFUN
WARNING: redefining UIOP/CONFIGURATION:REPORT-INVALID-FORM in DEFUN
WARNING: redefining UIOP/CONFIGURATION:VALIDATE-CONFIGURATION-FORM in DEFUN
WARNING: redefining UIOP/CONFIGURATION:VALIDATE-CONFIGURATION-FILE in DEFUN
WARNING: redefining UIOP/CONFIGURATION:VALIDATE-CONFIGURATION-DIRECTORY in DEFUN
WARNING: redefining UIOP/CONFIGURATION:RESOLVE-RELATIVE-LOCATION in DEFUN
WARNING: redefining UIOP/CONFIGURATION:RESOLVE-ABSOLUTE-LOCATION in DEFUN
WARNING: redefining UIOP/CONFIGURATION:RESOLVE-LOCATION in DEFUN
WARNING: redefining UIOP/CONFIGURATION:LOCATION-DESIGNATOR-P in DEFUN
WARNING: redefining UIOP/CONFIGURATION:LOCATION-FUNCTION-P in DEFUN
WARNING: redefining UIOP/CONFIGURATION:REGISTER-CLEAR-CONFIGURATION-HOOK in DEFUN
WARNING: redefining UIOP/CONFIGURATION:CLEAR-CONFIGURATION in DEFUN
WARNING: redefining UIOP/CONFIGURATION:UPGRADE-CONFIGURATION in DEFUN
WARNING: redefining UIOP/CONFIGURATION:GET-FOLDER-PATH in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-DATA-HOME in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-CONFIG-HOME in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-DATA-DIRS in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-CONFIG-DIRS in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-CACHE-HOME in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-RUNTIME-DIR in DEFUN
WARNING: redefining UIOP/CONFIGURATION:SYSTEM-CONFIG-PATHNAMES in DEFUN
WARNING: redefining UIOP/CONFIGURATION:FILTER-PATHNAME-SET in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-DATA-PATHNAMES in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-CONFIG-PATHNAMES in DEFUN
WARNING: redefining UIOP/CONFIGURATION:FIND-PREFERRED-FILE in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-DATA-PATHNAME in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-CONFIG-PATHNAME in DEFUN
WARNING: redefining UIOP/CONFIGURATION::COMPUTE-USER-CACHE in DEFUN
WARNING: redefining UIOP/CONFIGURATION:UIOP-DIRECTORY in DEFUN
WARNING: redefining UIOP/BACKWARD-DRIVER:COERCE-PATHNAME in DEFUN
WARNING: redefining UIOP/CONFIGURATION:USER-CONFIGURATION-DIRECTORIES in DEFUN
WARNING: redefining UIOP/CONFIGURATION:SYSTEM-CONFIGURATION-DIRECTORIES in DEFUN
WARNING: redefining UIOP/CONFIGURATION:IN-FIRST-DIRECTORY in DEFUN
WARNING: redefining UIOP/CONFIGURATION:IN-USER-CONFIGURATION-DIRECTORY in DEFUN
WARNING: redefining UIOP/CONFIGURATION:IN-SYSTEM-CONFIGURATION-DIRECTORY in DEFUN
WARNING: redefining UIOP/BACKWARD-DRIVER:VERSION-COMPATIBLE-P in DEFUN
Unhandled UIOP/PACKAGE::NO-SUCH-PACKAGE-ERROR in thread #<SB-THREAD:THREAD tid=87476 "main thread" RUNNING {1200F10003}>: No package named STATISTICS-1

Backtrace for: #<SB-THREAD:THREAD tid=87476 "main thread" RUNNING {1200F10003}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<UIOP/PACKAGE::NO-SUCH-PACKAGE-ERROR expected-type: UIOP/PACKAGE::PACKAGE-DESIGNATOR datum: #:STATISTICS-1> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* #<UIOP/PACKAGE::NO-SUCH-PACKAGE-ERROR expected-type: UIOP/PACKAGE::PACKAGE-DESIGNATOR datum: #:STATISTICS-1>)
2: (INVOKE-DEBUGGER #<UIOP/PACKAGE::NO-SUCH-PACKAGE-ERROR expected-type: UIOP/PACKAGE::PACKAGE-DESIGNATOR datum: #:STATISTICS-1>)
3: (ERROR UIOP/PACKAGE::NO-SUCH-PACKAGE-ERROR :DATUM #:STATISTICS-1)
4: (UIOP/PACKAGE:FIND-PACKAGE* #:STATISTICS-1 (#:ADD #:MAKE-SPARSE-COUNTER #:WEIGHTED-QUANTILES))
5: (UIOP/PACKAGE:ENSURE-PACKAGE #:DATA-FRAME :NICKNAMES (#:DF) :DOCUMENTATION NIL :USE (#:CL #:ALEXANDRIA #:ALEXANDRIA+ #:ANAPHORA #:LET-PLUS #:SELECT #:SELECT-DEV) :SHADOW NIL :SHADOWING-IMPORT-FROM NIL :IMPORT-FROM ((#:NU #:AS-ALIST) (#:STATISTICS-1 #:ADD #:MAKE-SPARSE-COUNTER #:WEIGHTED-QUANTILES) (#:AOPS #:&DIMS #:LINSPACE)) :EXPORT (#:*LARGE-DATA* #:LARGE-DATA #:DUPLICATE-KEY #:KEY-NOT-FOUND #:DATA-TYPE #:COLUMNS #:MAP-COLUMNS #:COLUMN #:COLUMN-TYPE #:COLUMN-NAMES #:KEYS #:COPY ...) :INTERN NIL :RECYCLE (#:DATA-FRAME #:DF) :MIX NIL :REEXPORT NIL :UNINTERN NIL :LOCAL-NICKNAMES NIL)
6: ((LAMBDA NIL :IN "/home/quicklisp/quicklisp-controller/dist/build-cache/data-frame/d402bfb52ade94015f2af1168ccd59fbf9660c7f/data-frame-20250828-git/src/pkgdcl.lisp"))
7: (SB-INT:SIMPLE-EVAL-IN-LEXENV (LET ((#1=#:G0 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #:DATA-FRAME) :NICKNAMES (QUOTE #) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE #) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...))) (PROGN (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION (FIND-PACKAGE #)) (SB-C:SOURCE-LOCATION)) #1#)) #<NULL-LEXENV>)
8: (SB-INT:SIMPLE-EVAL-IN-LEXENV (PROGN (LET ((#1=#:G0 (FUNCALL # # :NICKNAMES # :DOCUMENTATION # :USE # :SHADOW # :SHADOWING-IMPORT-FROM ...))) (PROGN (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION #) (SB-C:SOURCE-LOCATION)) #1#))) #<NULL-LEXENV>)
9: (EVAL-TLF (PROGN (LET ((#1=#:G0 (FUNCALL # # :NICKNAMES # :DOCUMENTATION # :USE # :SHADOW # :SHADOWING-IMPORT-FROM ...))) (PROGN (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION #) (SB-C:SOURCE-LOCATION)) #1#))) 0 #<NULL-LEXENV>)
10: ((FLET SB-C::FROB :IN SB-C::EVAL-COMPILE-TOPLEVEL))
11: (SB-C::EVAL-COMPILE-TOPLEVEL ((LET ((#1=#:G0 (FUNCALL # # :NICKNAMES # :DOCUMENTATION # :USE # :SHADOW # :SHADOWING-IMPORT-FROM ...))) (PROGN (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION #) (SB-C:SOURCE-LOCATION)) #1#))) ((LET ((#1=#:G0 #2=(FUNCALL # # :NICKNAMES # :DOCUMENTATION # :USE # :SHADOW # :SHADOWING-IMPORT-FROM ...))) (PROGN #3=(SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION #) (SB-C:SOURCE-LOCATION)) #1#)) #4=(PROG1 #2# #3#) #5=(EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) #4#) (PROGN #5#) SB-C::ORIGINAL-SOURCE-START 0 0))
12: (SB-C::PROCESS-TOPLEVEL-FORM (LET ((#1=#:G0 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #:DATA-FRAME) :NICKNAMES (QUOTE #) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE #) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...))) (PROGN (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION (FIND-PACKAGE #)) (SB-C:SOURCE-LOCATION)) #1#)) (#1=(PROG1 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #:DATA-FRAME) :NICKNAMES (QUOTE (#:DF)) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE (#:CL #:ALEXANDRIA #:ALEXANDRIA+ #:ANAPHORA #:LET-PLUS #:SELECT #:SELECT-DEV)) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...) (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION (FIND-PACKAGE #)) (SB-C:SOURCE-LOCATION))) #2=(EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) #1#) (PROGN #2#) SB-C::ORIGINAL-SOURCE-START 0 0) (:COMPILE-TOPLEVEL))
13: (SB-C::PROCESS-TOPLEVEL-FORM (PROG1 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #1=#:DATA-FRAME) :NICKNAMES (QUOTE (#:DF)) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE (#:CL #:ALEXANDRIA #:ALEXANDRIA+ #:ANAPHORA #:LET-PLUS #:SELECT #:SELECT-DEV)) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...) (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION (FIND-PACKAGE (QUOTE #1#))) (SB-C:SOURCE-LOCATION))) (#1=(EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (PROG1 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #:DATA-FRAME) :NICKNAMES (QUOTE #) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE #) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...) (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION #) (SB-C:SOURCE-LOCATION)))) (PROGN #1#) SB-C::ORIGINAL-SOURCE-START 0 0) (:COMPILE-TOPLEVEL))
14: (SB-C::PROCESS-TOPLEVEL-PROGN ((PROG1 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #:DATA-FRAME) :NICKNAMES (QUOTE (#:DF)) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE (#:CL #:ALEXANDRIA #:ALEXANDRIA+ #:ANAPHORA #:LET-PLUS #:SELECT #:SELECT-DEV)) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...) (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION (FIND-PACKAGE #)) (SB-C:SOURCE-LOCATION)))) (#1=(EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (PROG1 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #:DATA-FRAME) :NICKNAMES (QUOTE #) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE #) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...) (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION #) (SB-C:SOURCE-LOCATION)))) (PROGN #1#) SB-C::ORIGINAL-SOURCE-START 0 0) (:COMPILE-TOPLEVEL))
15: (SB-C::PROCESS-TOPLEVEL-FORM (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (PROG1 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #:DATA-FRAME) :NICKNAMES (QUOTE (#:DF)) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE (#:CL #:ALEXANDRIA #:ALEXANDRIA+ #:ANAPHORA #:LET-PLUS #:SELECT #:SELECT-DEV)) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...) (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION (FIND-PACKAGE #)) (SB-C:SOURCE-LOCATION)))) ((PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (PROG1 (FUNCALL # # :NICKNAMES # :DOCUMENTATION # :USE # :SHADOW # :SHADOWING-IMPORT-FROM ...) (SETF # #)))) SB-C::ORIGINAL-SOURCE-START 0 0) NIL)
16: (SB-C::PROCESS-TOPLEVEL-PROGN ((EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (PROG1 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #:DATA-FRAME) :NICKNAMES (QUOTE #) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE #) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...) (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION #) (SB-C:SOURCE-LOCATION))))) ((PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (PROG1 (FUNCALL # # :NICKNAMES # :DOCUMENTATION # :USE # :SHADOW # :SHADOWING-IMPORT-FROM ...) (SETF # #)))) SB-C::ORIGINAL-SOURCE-START 0 0) NIL)
17: (SB-C::PROCESS-TOPLEVEL-FORM (PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (PROG1 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #:DATA-FRAME) :NICKNAMES (QUOTE #) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE #) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...) (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION #) (SB-C:SOURCE-LOCATION))))) (SB-C::ORIGINAL-SOURCE-START 0 0) NIL)
18: (SB-C::PROCESS-TOPLEVEL-FORM (UIOP/PACKAGE:DEFINE-PACKAGE #:DATA-FRAME (:NICKNAMES #:DF) (:USE #:CL #:ALEXANDRIA #:ALEXANDRIA+ #:ANAPHORA #:LET-PLUS #:SELECT #:SELECT-DEV) (:IMPORT-FROM #:NU #:AS-ALIST) (:IMPORT-FROM #:STATISTICS-1 #:ADD #:MAKE-SPARSE-COUNTER #:WEIGHTED-QUANTILES) (:IMPORT-FROM #:AOPS #:&DIMS #:LINSPACE) (:EXPORT #:*LARGE-DATA* #:LARGE-DATA #:DUPLICATE-KEY #:KEY-NOT-FOUND #:DATA-TYPE #:COLUMNS #:MAP-COLUMNS #:COLUMN #:COLUMN-TYPE #:COLUMN-NAMES #:KEYS ...)) (SB-C::ORIGINAL-SOURCE-START 0 0) NIL)
19: ((LAMBDA (SB-KERNEL:FORM &KEY :CURRENT-INDEX &ALLOW-OTHER-KEYS) :IN SB-C::SUB-COMPILE-FILE) (UIOP/PACKAGE:DEFINE-PACKAGE #:DATA-FRAME (:NICKNAMES #:DF) (:USE #:CL #:ALEXANDRIA #:ALEXANDRIA+ #:ANAPHORA #:LET-PLUS #:SELECT #:SELECT-DEV) (:IMPORT-FROM #:NU #:AS-ALIST) (:IMPORT-FROM #:STATISTICS-1 #:ADD #:MAKE-SPARSE-COUNTER #:WEIGHTED-QUANTILES) (:IMPORT-FROM #:AOPS #:&DIMS #:LINSPACE) (:EXPORT #:*LARGE-DATA* #:LARGE-DATA #:DUPLICATE-KEY #:KEY-NOT-FOUND #:DATA-TYPE #:COLUMNS #:MAP-COLUMNS #:COLUMN #:COLUMN-TYPE #:COLUMN-NAMES #:KEYS ...)) :CURRENT-INDEX 0)
20: (SB-C::%DO-FORMS-FROM-INFO #<FUNCTION (LAMBDA (SB-KERNEL:FORM &KEY :CURRENT-INDEX &ALLOW-OTHER-KEYS) :IN SB-C::SUB-COMPILE-FILE) {B8003A567B}> #<SB-C::SOURCE-INFO {122A9BE2C3}> SB-C::INPUT-ERROR-IN-COMPILE-FILE)
21: ((LAMBDA NIL :IN SB-C::SUB-COMPILE-FILE))
22: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
23: (SB-C::SUB-COMPILE-FILE #<SB-C::SOURCE-INFO {122A9BE2C3}> NIL)
24: (COMPILE-FILE #P"/home/quicklisp/quicklisp-controller/dist/build-cache/data-frame/d402bfb52ade94015f2af1168ccd59fbf9660c7f/data-frame-20250828-git/src/pkgdcl.lisp" :OUTPUT-FILE #P#<(SIMPLE-ARRAY CHARACTER (226)) /home/quicklisp/.cache/common-lisp/sbcl-2.5.7.135-b5e53e27e-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/data-frame/d402bfb52ade94015f2af1168ccd59fbf9660c7f/data-frame-20250828-git/s... {122AAA9B9F}> :VERBOSE NIL :PRINT NIL :EXTERNAL-FORMAT :UTF-8 :PROGRESS NIL :TRACE-FILE NIL :BLOCK-COMPILE NIL :ENTRY-POINTS NIL :EMIT-CFASL NIL)
25: (UIOP/UTILITY:CALL-WITH-MUFFLED-CONDITIONS #<FUNCTION (LAMBDA NIL :IN UIOP/LISP-BUILD:COMPILE-FILE*) {122A99FB5B}> NIL)
26: (UIOP/PATHNAME:CALL-WITH-ENOUGH-PATHNAME #P"/home/quicklisp/quicklisp-controller/dist/build-cache/data-frame/d402bfb52ade94015f2af1168ccd59fbf9660c7f/data-frame-20250828-git/src/pkgdcl.lisp" NIL #<FUNCTION (LAMBDA (UIOP/LISP-BUILD::INPUT-FILE) :IN UIOP/LISP-BUILD:COMPILE-FILE*) {122A99F60B}>)
27: (UIOP/LISP-BUILD:COMPILE-FILE* #P"/home/quicklisp/quicklisp-controller/dist/build-cache/data-frame/d402bfb52ade94015f2af1168ccd59fbf9660c7f/data-frame-20250828-git/src/pkgdcl.lisp" :OUTPUT-FILE #P#<(SIMPLE-ARRAY CHARACTER (214)) /home/quicklisp/.cache/common-lisp/sbcl-2.5.7.135-b5e53e27e-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/data-frame/d402bfb52ade94015f2af1168ccd59fbf9660c7f/data-frame-20250828-git/s... {122AAC19EF}> :EXTERNAL-FORMAT :UTF-8 :WARNINGS-FILE NIL)
28: (ASDF/LISP-ACTION:PERFORM-LISP-COMPILATION #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "data-frame" "pkgdcl">)
29: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "data-frame" "pkgdcl">)
30: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
31: ((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS :AROUND (T T)) #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "data-frame" "pkgdcl">) [fast-method]
32: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {12045EE2D3}>) [fast-method]
33: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
34: ((:METHOD ASDF/PLAN:PERFORM-PLAN :AROUND (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {12045EE2D3}>) [fast-method]
35: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "data-frame/tests"> :PLAN-CLASS NIL :PLAN-OPTIONS NIL) [fast-method]
36: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "data-frame/tests">)
37: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
38: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "data-frame/tests">) [fast-method]
39: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "data-frame/tests")
40: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
41: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "data-frame/tests") [fast-method]
42: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {12045FD7EB}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
43: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
44: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {12045C474B}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
45: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "data-frame/tests") [fast-method]
46: (DEPCHECK::COMPUTE-DEPENDENCIES "data-frame" "data-frame/tests")
47: (DEPCHECK::MAGIC "data-frame" "data-frame/tests" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-GHK22Pi8/depcheck-win.txt")
48: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "data-frame" "data-frame/tests" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-GHK22Pi8/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-GHK22Pi8/depcheck-fail.txt"))
49: ((LAMBDA NIL :IN "/home/quicklisp/quicklisp/local-projects/quicklisp-controller/dumper-2SKVI5f7.lisp"))
50: ((FLET SB-UNIX::BODY :IN SB-IMPL::START-LISP))
51: ((FLET "WITHOUT-INTERRUPTS-BODY-3" :IN SB-IMPL::START-LISP))
52: (SB-IMPL::%START-LISP)

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

data-frame

WARNING: redefining UIOP/PACKAGE:FIND-PACKAGE* in DEFUN
WARNING: redefining UIOP/PACKAGE:FIND-SYMBOL* in DEFUN
WARNING: redefining UIOP/PACKAGE:SYMBOL-CALL in DEFUN
WARNING: redefining UIOP/PACKAGE:INTERN* in DEFUN
WARNING: redefining UIOP/PACKAGE:EXPORT* in DEFUN
WARNING: redefining UIOP/PACKAGE:IMPORT* in DEFUN
WARNING: redefining UIOP/PACKAGE:SHADOWING-IMPORT* in DEFUN
WARNING: redefining UIOP/PACKAGE:SHADOW* in DEFUN
WARNING: redefining UIOP/PACKAGE:MAKE-SYMBOL* in DEFUN
WARNING: redefining UIOP/PACKAGE:UNINTERN* in DEFUN
WARNING: redefining UIOP/PACKAGE:SYMBOL-SHADOWING-P in DEFUN
WARNING: redefining UIOP/PACKAGE:HOME-PACKAGE-P in DEFUN
WARNING: redefining UIOP/PACKAGE:SYMBOL-PACKAGE-NAME in DEFUN
WARNING: redefining UIOP/PACKAGE:STANDARD-COMMON-LISP-SYMBOL-P in DEFUN
WARNING: redefining UIOP/PACKAGE:REIFY-PACKAGE in DEFUN
WARNING: redefining UIOP/PACKAGE:UNREIFY-PACKAGE in DEFUN
WARNING: redefining UIOP/PACKAGE:REIFY-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE:UNREIFY-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE::RECORD-FISHY in DEFUN
WARNING: redefining UIOP/PACKAGE::WHEN-PACKAGE-FISHINESS in DEFMACRO
WARNING: redefining UIOP/PACKAGE::NOTE-PACKAGE-FISHINESS in DEFMACRO
WARNING: redefining UIOP/PACKAGE::SET-DUMMY-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE::MAKE-DUMMY-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE::DUMMY-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE::GET-DUMMY-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE:NUKE-SYMBOL-IN-PACKAGE in DEFUN
WARNING: redefining UIOP/PACKAGE:NUKE-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE:REHOME-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE:ENSURE-PACKAGE-UNUSED in DEFUN
WARNING: redefining UIOP/PACKAGE:DELETE-PACKAGE* in DEFUN
WARNING: redefining UIOP/PACKAGE:PACKAGE-NAMES in DEFUN
WARNING: redefining UIOP/PACKAGE:PACKAGES-FROM-NAMES in DEFUN
WARNING: redefining UIOP/PACKAGE:FRESH-PACKAGE-NAME in DEFUN
WARNING: redefining UIOP/PACKAGE:RENAME-PACKAGE-AWAY in DEFUN
WARNING: redefining UIOP/PACKAGE:PACKAGE-DEFINITION-FORM in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-SHADOWING-IMPORT in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-IMPORTED in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-IMPORT in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-INHERITED in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-MIX in DEFUN
WARNING: redefining UIOP/PACKAGE::RECYCLE-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE::SYMBOL-RECYCLED-P in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-EXPORTED-TO-USER in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-EXPORTED in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-EXPORT in DEFUN
WARNING: redefining UIOP/PACKAGE::INSTALL-PACKAGE-LOCAL-NICKNAMES in DEFUN
WARNING: redefining UIOP/PACKAGE:ENSURE-PACKAGE in DEFUN
WARNING: redefining UIOP/PACKAGE:PARSE-DEFINE-PACKAGE-FORM in DEFUN
WARNING: redefining UIOP/PACKAGE:DEFINE-PACKAGE in DEFMACRO
WARNING: redefining UIOP/COMMON-LISP::FROB-SUBSTRINGS in DEFUN
WARNING: redefining UIOP/COMMON-LISP::COMPATFMT in DEFMACRO
WARNING: redefining UIOP/UTILITY::ENSURE-FUNCTION-NOTINLINE in DEFUN
WARNING: redefining UIOP/UTILITY:WITH-UPGRADABILITY in DEFMACRO
WARNING: redefining UIOP/UTILITY:UIOP-DEBUG in DEFMACRO
WARNING: redefining UIOP/UTILITY:LOAD-UIOP-DEBUG-UTILITY in DEFUN
WARNING: redefining UIOP/UTILITY:NEST in DEFMACRO
WARNING: redefining UIOP/UTILITY:IF-LET in DEFMACRO
WARNING: redefining UIOP/UTILITY:PARSE-BODY in DEFUN
WARNING: redefining UIOP/UTILITY:WHILE-COLLECTING in DEFMACRO
WARNING: redefining UIOP/UTILITY:APPENDF in DEFMACRO
WARNING: redefining UIOP/UTILITY:LENGTH=N-P in DEFUN
WARNING: redefining UIOP/UTILITY:ENSURE-LIST in DEFUN
WARNING: redefining UIOP/UTILITY:REMOVE-PLIST-KEY in DEFUN
WARNING: redefining UIOP/UTILITY:REMOVE-PLIST-KEYS in DEFUN
WARNING: redefining UIOP/UTILITY:EMPTYP in DEFUN
WARNING: redefining UIOP/UTILITY:CHARACTER-TYPE-INDEX in DEFUN
WARNING: redefining UIOP/UTILITY:BASE-STRING-P in DEFUN
WARNING: redefining UIOP/UTILITY:STRINGS-COMMON-ELEMENT-TYPE in DEFUN
WARNING: redefining UIOP/UTILITY:REDUCE/STRCAT in DEFUN
WARNING: redefining UIOP/UTILITY:STRCAT in DEFUN
WARNING: redefining UIOP/UTILITY:FIRST-CHAR in DEFUN
WARNING: redefining UIOP/UTILITY:LAST-CHAR in DEFUN
WARNING: redefining UIOP/UTILITY:SPLIT-STRING in DEFUN
WARNING: redefining UIOP/UTILITY:STRING-PREFIX-P in DEFUN
WARNING: redefining UIOP/UTILITY:STRING-SUFFIX-P in DEFUN
WARNING: redefining UIOP/UTILITY:STRING-ENCLOSED-P in DEFUN
WARNING: redefining UIOP/UTILITY:STRIPLN in DEFUN
WARNING: redefining UIOP/UTILITY:STANDARD-CASE-SYMBOL-NAME in DEFUN
WARNING: redefining UIOP/UTILITY:FIND-STANDARD-CASE-SYMBOL in DEFUN
WARNING: redefining UIOP/UTILITY:TIMESTAMP< in DEFUN
WARNING: redefining UIOP/UTILITY:TIMESTAMPS< in DEFUN
WARNING: redefining UIOP/UTILITY:TIMESTAMP*< in DEFUN
WARNING: redefining UIOP/UTILITY:TIMESTAMP<= in DEFUN
WARNING: redefining UIOP/UTILITY:EARLIER-TIMESTAMP in DEFUN
WARNING: redefining UIOP/UTILITY:TIMESTAMPS-EARLIEST in DEFUN
WARNING: redefining UIOP/UTILITY:EARLIEST-TIMESTAMP in DEFUN
WARNING: redefining UIOP/UTILITY:LATER-TIMESTAMP in DEFUN
WARNING: redefining UIOP/UTILITY:TIMESTAMPS-LATEST in DEFUN
WARNING: redefining UIOP/UTILITY:LATEST-TIMESTAMP in DEFUN
WARNING: redefining UIOP/UTILITY:LATEST-TIMESTAMP-F in DEFMACRO
WARNING: redefining UIOP/UTILITY:ENSURE-FUNCTION in DEFUN
WARNING: redefining UIOP/UTILITY:ACCESS-AT in DEFUN
WARNING: redefining UIOP/UTILITY:ACCESS-AT-COUNT in DEFUN
WARNING: redefining UIOP/UTILITY:CALL-FUNCTION in DEFUN
WARNING: redefining UIOP/UTILITY:CALL-FUNCTIONS in DEFUN
WARNING: redefining UIOP/UTILITY:REGISTER-HOOK-FUNCTION in DEFUN
WARNING: redefining UIOP/UTILITY:COERCE-CLASS in DEFUN
WARNING: redefining UIOP/UTILITY:ENSURE-GETHASH in DEFUN
WARNING: redefining UIOP/UTILITY:LIST-TO-HASH-SET in DEFUN
WARNING: redefining UIOP/UTILITY:LEXICOGRAPHIC< in DEFUN
WARNING: redefining UIOP/UTILITY:LEXICOGRAPHIC<= in DEFUN
WARNING: redefining UIOP/UTILITY:STYLE-WARN in DEFUN
WARNING: redefining UIOP/UTILITY:MATCH-CONDITION-P in DEFUN
WARNING: redefining UIOP/UTILITY:MATCH-ANY-CONDITION-P in DEFUN
WARNING: redefining UIOP/UTILITY:CALL-WITH-MUFFLED-CONDITIONS in DEFUN
WARNING: redefining UIOP/UTILITY:WITH-MUFFLED-CONDITIONS in DEFMACRO
WARNING: redefining UIOP/UTILITY:NOT-IMPLEMENTED-ERROR in DEFUN
WARNING: redefining UIOP/UTILITY:PARAMETER-ERROR in DEFUN
WARNING: redefining UIOP/UTILITY:BOOLEAN-TO-FEATURE-EXPRESSION in DEFUN
WARNING: redefining UIOP/UTILITY:SYMBOL-TEST-TO-FEATURE-EXPRESSION in DEFUN
WARNING: redefining UIOP/VERSION:UNPARSE-VERSION in DEFUN
WARNING: redefining UIOP/VERSION:PARSE-VERSION in DEFUN
WARNING: redefining UIOP/VERSION:NEXT-VERSION in DEFUN
WARNING: redefining UIOP/VERSION:VERSION< in DEFUN
WARNING: redefining UIOP/VERSION:VERSION<= in DEFUN
WARNING: redefining UIOP/VERSION::DEPRECATED-FUNCTION-CONDITION-KIND in DEFUN
WARNING: redefining PRINT-OBJECT (#<SB-PCL::CONDITION-CLASS UIOP/VERSION:DEPRECATED-FUNCTION-CONDITION> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining UIOP/VERSION::NOTIFY-DEPRECATED-FUNCTION in DEFUN
WARNING: redefining UIOP/VERSION:VERSION-DEPRECATION in DEFUN
WARNING: redefining UIOP/VERSION:WITH-DEPRECATION in DEFMACRO
WARNING: redefining UIOP/OS:FEATUREP in DEFUN
WARNING: redefining UIOP/OS:OS-MACOSX-P in DEFUN
WARNING: redefining UIOP/OS:OS-UNIX-P in DEFUN
WARNING: redefining UIOP/OS:OS-WINDOWS-P in DEFUN
WARNING: redefining UIOP/OS:OS-GENERA-P in DEFUN
WARNING: redefining UIOP/OS::OS-OLDMAC-P in DEFUN
WARNING: redefining UIOP/OS::OS-HAIKU-P in DEFUN
WARNING: redefining UIOP/OS::OS-MEZZANO-P in DEFUN
WARNING: redefining UIOP/OS:DETECT-OS in DEFUN
WARNING: redefining UIOP/OS:OS-COND in DEFMACRO
WARNING: redefining UIOP/OS:GETENV in DEFUN
WARNING: redefining UIOP/OS:GETENVP in DEFUN
WARNING: redefining UIOP/OS::FIRST-FEATURE in DEFUN
WARNING: redefining UIOP/OS:IMPLEMENTATION-TYPE in DEFUN
WARNING: redefining UIOP/OS:OPERATING-SYSTEM in DEFUN
WARNING: redefining UIOP/OS:ARCHITECTURE in DEFUN
WARNING: redefining UIOP/OS:LISP-VERSION-STRING in DEFUN
WARNING: redefining UIOP/OS:IMPLEMENTATION-IDENTIFIER in DEFUN
WARNING: redefining UIOP/OS:HOSTNAME in DEFUN
WARNING: redefining UIOP/OS:GETCWD in DEFUN
WARNING: redefining UIOP/OS:CHDIR in DEFUN
WARNING: redefining UIOP/OS:READ-NULL-TERMINATED-STRING in DEFUN
WARNING: redefining UIOP/OS:READ-LITTLE-ENDIAN in DEFUN
WARNING: redefining UIOP/OS:PARSE-FILE-LOCATION-INFO in DEFUN
WARNING: redefining UIOP/OS:PARSE-WINDOWS-SHORTCUT in DEFUN
WARNING: redefining UIOP/PATHNAME:NORMALIZE-PATHNAME-DIRECTORY-COMPONENT in DEFUN
WARNING: redefining UIOP/PATHNAME:DENORMALIZE-PATHNAME-DIRECTORY-COMPONENT in DEFUN
WARNING: redefining UIOP/PATHNAME:MERGE-PATHNAME-DIRECTORY-COMPONENTS in DEFUN
WARNING: redefining UIOP/PATHNAME:MAKE-PATHNAME* in DEFUN
WARNING: redefining UIOP/PATHNAME:MAKE-PATHNAME-COMPONENT-LOGICAL in DEFUN
WARNING: redefining UIOP/PATHNAME:MAKE-PATHNAME-LOGICAL in DEFUN
WARNING: redefining UIOP/PATHNAME:MERGE-PATHNAMES* in DEFUN
WARNING: redefining UIOP/PATHNAME:LOGICAL-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:PHYSICAL-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:PHYSICALIZE-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:NIL-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:WITH-PATHNAME-DEFAULTS in DEFMACRO
WARNING: redefining UIOP/PATHNAME:PATHNAME-EQUAL in DEFUN
WARNING: redefining UIOP/PATHNAME:ABSOLUTE-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:RELATIVE-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:HIDDEN-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:FILE-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:PATHNAME-DIRECTORY-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:PATHNAME-PARENT-DIRECTORY-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:DIRECTORY-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:ENSURE-DIRECTORY-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:SPLIT-UNIX-NAMESTRING-DIRECTORY-COMPONENTS in DEFUN
WARNING: redefining UIOP/PATHNAME:SPLIT-NAME-TYPE in DEFUN
WARNING: redefining UIOP/PATHNAME:PARSE-UNIX-NAMESTRING in DEFUN
WARNING: redefining UIOP/PATHNAME:UNIX-NAMESTRING in DEFUN
WARNING: redefining UIOP/PATHNAME:SUBPATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:SUBPATHNAME* in DEFUN
WARNING: redefining UIOP/PATHNAME:PATHNAME-ROOT in DEFUN
WARNING: redefining UIOP/PATHNAME:PATHNAME-HOST-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:ENSURE-ABSOLUTE-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:SUBPATHP in DEFUN
WARNING: redefining UIOP/PATHNAME:ENOUGH-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:CALL-WITH-ENOUGH-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:WITH-ENOUGH-PATHNAME in DEFMACRO
WARNING: redefining UIOP/PATHNAME:WILDEN in DEFUN
WARNING: redefining UIOP/PATHNAME:RELATIVIZE-DIRECTORY-COMPONENT in DEFUN
WARNING: redefining UIOP/PATHNAME:RELATIVIZE-PATHNAME-DIRECTORY in DEFUN
WARNING: redefining UIOP/PATHNAME:DIRECTORY-SEPARATOR-FOR-HOST in DEFUN
WARNING: redefining UIOP/PATHNAME:DIRECTORIZE-PATHNAME-HOST-DEVICE in DEFUN
WARNING: redefining UIOP/PATHNAME:TRANSLATE-PATHNAME* in DEFUN
WARNING: redefining UIOP/FILESYSTEM:NATIVE-NAMESTRING in DEFUN
WARNING: redefining UIOP/FILESYSTEM:PARSE-NATIVE-NAMESTRING in DEFUN
WARNING: redefining UIOP/FILESYSTEM:TRUENAME* in DEFUN
WARNING: redefining UIOP/FILESYSTEM:SAFE-FILE-WRITE-DATE in DEFUN
WARNING: redefining UIOP/FILESYSTEM:PROBE-FILE* in DEFUN
WARNING: redefining UIOP/FILESYSTEM:DIRECTORY-EXISTS-P in DEFUN
WARNING: redefining UIOP/FILESYSTEM:FILE-EXISTS-P in DEFUN
WARNING: redefining UIOP/FILESYSTEM:DIRECTORY* in DEFUN
WARNING: redefining UIOP/FILESYSTEM:FILTER-LOGICAL-DIRECTORY-RESULTS in DEFUN
WARNING: redefining UIOP/FILESYSTEM:DIRECTORY-FILES in DEFUN
WARNING: redefining UIOP/FILESYSTEM:SUBDIRECTORIES in DEFUN
WARNING: redefining UIOP/FILESYSTEM:COLLECT-SUB*DIRECTORIES in DEFUN
WARNING: redefining UIOP/FILESYSTEM:TRUENAMIZE in DEFUN
WARNING: redefining UIOP/FILESYSTEM:RESOLVE-SYMLINKS in DEFUN
WARNING: redefining UIOP/FILESYSTEM:RESOLVE-SYMLINKS* in DEFUN
WARNING: redefining UIOP/PATHNAME:ENSURE-PATHNAME in DEFUN
WARNING: redefining UIOP/FILESYSTEM:GET-PATHNAME-DEFAULTS in DEFUN
WARNING: redefining UIOP/FILESYSTEM:CALL-WITH-CURRENT-DIRECTORY in DEFUN
WARNING: redefining UIOP/FILESYSTEM:WITH-CURRENT-DIRECTORY in DEFMACRO
WARNING: redefining UIOP/FILESYSTEM:INTER-DIRECTORY-SEPARATOR in DEFUN
WARNING: redefining UIOP/FILESYSTEM:SPLIT-NATIVE-PATHNAMES-STRING in DEFUN
WARNING: redefining UIOP/FILESYSTEM:GETENV-PATHNAME in DEFUN
WARNING: redefining UIOP/FILESYSTEM:GETENV-PATHNAMES in DEFUN
WARNING: redefining UIOP/FILESYSTEM:GETENV-ABSOLUTE-DIRECTORY in DEFUN
WARNING: redefining UIOP/FILESYSTEM:GETENV-ABSOLUTE-DIRECTORIES in DEFUN
WARNING: redefining UIOP/FILESYSTEM:LISP-IMPLEMENTATION-DIRECTORY in DEFUN
WARNING: redefining UIOP/FILESYSTEM:LISP-IMPLEMENTATION-PATHNAME-P in DEFUN
WARNING: redefining UIOP/FILESYSTEM:ENSURE-ALL-DIRECTORIES-EXIST in DEFUN
WARNING: redefining UIOP/FILESYSTEM:DELETE-FILE-IF-EXISTS in DEFUN
WARNING: redefining UIOP/FILESYSTEM:RENAME-FILE-OVERWRITING-TARGET in DEFUN
WARNING: redefining UIOP/FILESYSTEM:DELETE-EMPTY-DIRECTORY in DEFUN
WARNING: redefining UIOP/FILESYSTEM:DELETE-DIRECTORY-TREE in DEFUN
WARNING: redefining UIOP/STREAM:SETUP-STDIN in DEFUN
WARNING: redefining UIOP/STREAM:SETUP-STDOUT in DEFUN
WARNING: redefining UIOP/STREAM:SETUP-STDERR in DEFUN
WARNING: redefining UIOP/STREAM:ALWAYS-DEFAULT-ENCODING in DEFUN
WARNING: redefining UIOP/STREAM:DETECT-ENCODING in DEFUN
WARNING: redefining UIOP/STREAM:DEFAULT-ENCODING-EXTERNAL-FORMAT in DEFUN
WARNING: redefining UIOP/STREAM:ENCODING-EXTERNAL-FORMAT in DEFUN
WARNING: redefining UIOP/STREAM:WITH-SAFE-IO-SYNTAX in DEFMACRO
WARNING: redefining UIOP/STREAM:CALL-WITH-SAFE-IO-SYNTAX in DEFUN
WARNING: redefining UIOP/STREAM:SAFE-READ-FROM-STRING in DEFUN
WARNING: redefining UIOP/STREAM:CALL-WITH-OUTPUT-FILE in DEFUN
WARNING: redefining UIOP/STREAM:WITH-OUTPUT-FILE in DEFMACRO
WARNING: redefining UIOP/STREAM::CALL-WITH-OUTPUT in DEFUN
WARNING: redefining UIOP/STREAM:OUTPUT-STRING in DEFUN
WARNING: redefining UIOP/STREAM:CALL-WITH-INPUT-FILE in DEFUN
WARNING: redefining UIOP/STREAM:WITH-INPUT-FILE in DEFMACRO
WARNING: redefining UIOP/STREAM::CALL-WITH-INPUT in DEFUN
WARNING: redefining UIOP/STREAM:WITH-INPUT in DEFMACRO
WARNING: redefining UIOP/STREAM:INPUT-STRING in DEFUN
WARNING: redefining UIOP/STREAM:NULL-DEVICE-PATHNAME in DEFUN
WARNING: redefining UIOP/STREAM:CALL-WITH-NULL-INPUT in DEFUN
WARNING: redefining UIOP/STREAM:WITH-NULL-INPUT in DEFMACRO
WARNING: redefining UIOP/STREAM:CALL-WITH-NULL-OUTPUT in DEFUN
WARNING: redefining UIOP/STREAM:WITH-NULL-OUTPUT in DEFMACRO
WARNING: redefining UIOP/STREAM:FINISH-OUTPUTS in DEFUN
WARNING: redefining UIOP/STREAM:FORMAT! in DEFUN
WARNING: redefining UIOP/STREAM:SAFE-FORMAT! in DEFUN
WARNING: redefining UIOP/STREAM:COPY-STREAM-TO-STREAM in DEFUN
WARNING: redefining UIOP/STREAM:CONCATENATE-FILES in DEFUN
WARNING: redefining UIOP/STREAM:COPY-FILE in DEFUN
WARNING: redefining UIOP/STREAM:SLURP-STREAM-STRING in DEFUN
WARNING: redefining UIOP/STREAM:SLURP-STREAM-LINES in DEFUN
WARNING: redefining UIOP/STREAM:SLURP-STREAM-LINE in DEFUN
WARNING: redefining UIOP/STREAM:SLURP-STREAM-FORMS in DEFUN
WARNING: redefining UIOP/STREAM:SLURP-STREAM-FORM in DEFUN
WARNING: redefining UIOP/STREAM:READ-FILE-STRING in DEFUN
WARNING: redefining UIOP/STREAM:READ-FILE-LINES in DEFUN
WARNING: redefining UIOP/STREAM:READ-FILE-LINE in DEFUN
WARNING: redefining UIOP/STREAM:READ-FILE-FORMS in DEFUN
WARNING: redefining UIOP/STREAM:READ-FILE-FORM in DEFUN
WARNING: redefining UIOP/STREAM:SAFE-READ-FILE-LINE in DEFUN
WARNING: redefining UIOP/STREAM:SAFE-READ-FILE-FORM in DEFUN
WARNING: redefining UIOP/STREAM:EVAL-INPUT in DEFUN
WARNING: redefining UIOP/STREAM:EVAL-THUNK in DEFUN
WARNING: redefining UIOP/STREAM:STANDARD-EVAL-THUNK in DEFUN
WARNING: redefining UIOP/STREAM:PRINTLN in DEFUN
WARNING: redefining UIOP/STREAM:WRITELN in DEFUN
WARNING: redefining UIOP/STREAM:DEFAULT-TEMPORARY-DIRECTORY in DEFUN
WARNING: redefining UIOP/STREAM:TEMPORARY-DIRECTORY in DEFUN
WARNING: redefining UIOP/STREAM:SETUP-TEMPORARY-DIRECTORY in DEFUN
WARNING: redefining UIOP/STREAM:CALL-WITH-TEMPORARY-FILE in DEFUN
WARNING: redefining UIOP/STREAM:WITH-TEMPORARY-FILE in DEFMACRO
WARNING: redefining UIOP/STREAM::GET-TEMPORARY-FILE in DEFUN
WARNING: redefining UIOP/STREAM:ADD-PATHNAME-SUFFIX in DEFUN
WARNING: redefining UIOP/STREAM:TMPIZE-PATHNAME in DEFUN
WARNING: redefining UIOP/STREAM:CALL-WITH-STAGING-PATHNAME in DEFUN
WARNING: redefining UIOP/STREAM:WITH-STAGING-PATHNAME in DEFMACRO
WARNING: redefining UIOP/STREAM:FILE-STREAM-P in DEFUN
WARNING: redefining UIOP/STREAM:FILE-OR-SYNONYM-STREAM-P in DEFUN
WARNING: redefining UIOP/IMAGE:QUIT in DEFUN
WARNING: redefining UIOP/IMAGE:DIE in DEFUN
WARNING: redefining UIOP/IMAGE:RAW-PRINT-BACKTRACE in DEFUN
WARNING: redefining UIOP/IMAGE:PRINT-BACKTRACE in DEFUN
WARNING: redefining UIOP/IMAGE:PRINT-CONDITION-BACKTRACE in DEFUN
WARNING: redefining UIOP/IMAGE:FATAL-CONDITION-P in DEFUN
WARNING: redefining UIOP/IMAGE:HANDLE-FATAL-CONDITION in DEFUN
WARNING: redefining UIOP/IMAGE:CALL-WITH-FATAL-CONDITION-HANDLER in DEFUN
WARNING: redefining UIOP/IMAGE:WITH-FATAL-CONDITION-HANDLER in DEFMACRO
WARNING: redefining UIOP/IMAGE:SHELL-BOOLEAN-EXIT in DEFUN
WARNING: redefining UIOP/IMAGE:REGISTER-IMAGE-RESTORE-HOOK in DEFUN
WARNING: redefining UIOP/IMAGE:REGISTER-IMAGE-DUMP-HOOK in DEFUN
WARNING: redefining UIOP/IMAGE:CALL-IMAGE-RESTORE-HOOK in DEFUN
WARNING: redefining UIOP/IMAGE:CALL-IMAGE-DUMP-HOOK in DEFUN
WARNING: redefining UIOP/IMAGE:RAW-COMMAND-LINE-ARGUMENTS in DEFUN
WARNING: redefining UIOP/IMAGE:COMMAND-LINE-ARGUMENTS in DEFUN
WARNING: redefining UIOP/IMAGE:ARGV0 in DEFUN
WARNING: redefining UIOP/IMAGE:SETUP-COMMAND-LINE-ARGUMENTS in DEFUN
WARNING: redefining UIOP/IMAGE:RESTORE-IMAGE in DEFUN
WARNING: redefining UIOP/IMAGE:DUMP-IMAGE in DEFUN
WARNING: redefining UIOP/IMAGE:CREATE-IMAGE in DEFUN
WARNING: redefining UIOP/LISP-BUILD::SB-GROVEL-UNKNOWN-CONSTANT-CONDITION-P in DEFUN
WARNING: redefining UIOP/LISP-BUILD:CALL-WITH-MUFFLED-COMPILER-CONDITIONS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:WITH-MUFFLED-COMPILER-CONDITIONS in DEFMACRO
WARNING: redefining UIOP/LISP-BUILD:CALL-WITH-MUFFLED-LOADER-CONDITIONS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:WITH-MUFFLED-LOADER-CONDITIONS in DEFMACRO
WARNING: redefining UIOP/LISP-BUILD:CHECK-LISP-COMPILE-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:CHECK-LISP-COMPILE-RESULTS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:REIFY-SIMPLE-SEXP in DEFUN
WARNING: redefining UIOP/LISP-BUILD:UNREIFY-SIMPLE-SEXP in DEFUN
WARNING: redefining UIOP/LISP-BUILD::REIFY-UNDEFINED-WARNING in DEFUN
WARNING: redefining UIOP/LISP-BUILD:REIFY-DEFERRED-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:UNREIFY-DEFERRED-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:RESET-DEFERRED-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:SAVE-DEFERRED-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:WARNINGS-FILE-TYPE in DEFUN
WARNING: redefining UIOP/LISP-BUILD:ENABLE-DEFERRED-WARNINGS-CHECK in DEFUN
WARNING: redefining UIOP/LISP-BUILD:DISABLE-DEFERRED-WARNINGS-CHECK in DEFUN
WARNING: redefining UIOP/LISP-BUILD:WARNINGS-FILE-P in DEFUN
WARNING: redefining UIOP/LISP-BUILD:CHECK-DEFERRED-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD::CALL-WITH-SAVED-DEFERRED-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:WITH-SAVED-DEFERRED-WARNINGS in DEFMACRO
WARNING: redefining UIOP/LISP-BUILD:CURRENT-LISP-FILE-PATHNAME in DEFUN
WARNING: redefining UIOP/LISP-BUILD:LOAD-PATHNAME in DEFUN
WARNING: redefining UIOP/LISP-BUILD:LISPIZE-PATHNAME in DEFUN
WARNING: redefining UIOP/LISP-BUILD:COMPILE-FILE-TYPE in DEFUN
WARNING: redefining UIOP/LISP-BUILD:CALL-AROUND-HOOK in DEFUN
WARNING: redefining UIOP/LISP-BUILD:COMPILE-FILE-PATHNAME* in DEFUN
WARNING: redefining UIOP/LISP-BUILD:COMPILE-FILE* in DEFUN
WARNING: redefining UIOP/LISP-BUILD:LOAD* in DEFUN
WARNING: redefining UIOP/LISP-BUILD:LOAD-FROM-STRING in DEFUN
WARNING: redefining UIOP/LISP-BUILD:COMBINE-FASLS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::REQUIRES-ESCAPING-P in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-TOKEN in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::ESCAPE-WINDOWS-TOKEN-WITHIN-DOUBLE-QUOTES in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::EASY-WINDOWS-CHARACTER-P in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-WINDOWS-TOKEN in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::ESCAPE-SH-TOKEN-WITHIN-DOUBLE-QUOTES in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:EASY-SH-CHARACTER-P in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-SH-TOKEN in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-SHELL-TOKEN in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-COMMAND in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-WINDOWS-COMMAND in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-SH-COMMAND in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-SHELL-COMMAND in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%NORMALIZE-IO-SPECIFIER in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%INTERACTIVEP in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%SIGNAL-TO-EXIT-CODE in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%CODE-TO-STATUS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%HANDLE-IF-EXISTS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%HANDLE-IF-DOES-NOT-EXIST in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:PROCESS-INFO-ERROR-OUTPUT in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:PROCESS-INFO-INPUT in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:PROCESS-INFO-OUTPUT in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:PROCESS-INFO-PID in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%PROCESS-STATUS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:PROCESS-ALIVE-P in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:WAIT-PROCESS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%POSIX-SEND-SIGNAL in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:TERMINATE-PROCESS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:CLOSE-STREAMS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:LAUNCH-PROGRAM in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::CALL-STREAM-PROCESSOR in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM:SLURP-INPUT-STREAM in DEFGENERIC
WARNING: redefining SLURP-INPUT-STREAM (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:FUNCTION> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:CONS> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:STREAM> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER STRING> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER :STRING> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER :LINES> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER :LINE> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER :FORMS> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER :FORM> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER T> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:NULL> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:PATHNAME> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:T> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining UIOP/RUN-PROGRAM:VOMIT-OUTPUT-STREAM in DEFGENERIC
WARNING: redefining VOMIT-OUTPUT-STREAM (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:FUNCTION> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:CONS> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:STREAM> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:STRING> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER T> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:NULL> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:PATHNAME> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:T> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining UIOP/RUN-PROGRAM::%CHECK-RESULT in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%ACTIVE-IO-SPECIFIER-P in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%RUN-PROGRAM in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%CALL-WITH-PROGRAM-IO in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::PLACE-SETTER in DEFMACRO
WARNING: redefining UIOP/RUN-PROGRAM::WITH-PROGRAM-INPUT in DEFMACRO
WARNING: redefining UIOP/RUN-PROGRAM::WITH-PROGRAM-OUTPUT in DEFMACRO
WARNING: redefining UIOP/RUN-PROGRAM::WITH-PROGRAM-ERROR-OUTPUT in DEFMACRO
WARNING: redefining UIOP/RUN-PROGRAM::%USE-LAUNCH-PROGRAM in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%NORMALIZE-SYSTEM-COMMAND in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%REDIRECTED-SYSTEM-COMMAND in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%SYSTEM in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%USE-SYSTEM in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM:RUN-PROGRAM in DEFUN
WARNING: redefining UIOP/CONFIGURATION:CONFIGURATION-INHERITANCE-DIRECTIVE-P in DEFUN
WARNING: redefining UIOP/CONFIGURATION:REPORT-INVALID-FORM in DEFUN
WARNING: redefining UIOP/CONFIGURATION:VALIDATE-CONFIGURATION-FORM in DEFUN
WARNING: redefining UIOP/CONFIGURATION:VALIDATE-CONFIGURATION-FILE in DEFUN
WARNING: redefining UIOP/CONFIGURATION:VALIDATE-CONFIGURATION-DIRECTORY in DEFUN
WARNING: redefining UIOP/CONFIGURATION:RESOLVE-RELATIVE-LOCATION in DEFUN
WARNING: redefining UIOP/CONFIGURATION:RESOLVE-ABSOLUTE-LOCATION in DEFUN
WARNING: redefining UIOP/CONFIGURATION:RESOLVE-LOCATION in DEFUN
WARNING: redefining UIOP/CONFIGURATION:LOCATION-DESIGNATOR-P in DEFUN
WARNING: redefining UIOP/CONFIGURATION:LOCATION-FUNCTION-P in DEFUN
WARNING: redefining UIOP/CONFIGURATION:REGISTER-CLEAR-CONFIGURATION-HOOK in DEFUN
WARNING: redefining UIOP/CONFIGURATION:CLEAR-CONFIGURATION in DEFUN
WARNING: redefining UIOP/CONFIGURATION:UPGRADE-CONFIGURATION in DEFUN
WARNING: redefining UIOP/CONFIGURATION:GET-FOLDER-PATH in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-DATA-HOME in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-CONFIG-HOME in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-DATA-DIRS in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-CONFIG-DIRS in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-CACHE-HOME in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-RUNTIME-DIR in DEFUN
WARNING: redefining UIOP/CONFIGURATION:SYSTEM-CONFIG-PATHNAMES in DEFUN
WARNING: redefining UIOP/CONFIGURATION:FILTER-PATHNAME-SET in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-DATA-PATHNAMES in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-CONFIG-PATHNAMES in DEFUN
WARNING: redefining UIOP/CONFIGURATION:FIND-PREFERRED-FILE in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-DATA-PATHNAME in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-CONFIG-PATHNAME in DEFUN
WARNING: redefining UIOP/CONFIGURATION::COMPUTE-USER-CACHE in DEFUN
WARNING: redefining UIOP/CONFIGURATION:UIOP-DIRECTORY in DEFUN
WARNING: redefining UIOP/BACKWARD-DRIVER:COERCE-PATHNAME in DEFUN
WARNING: redefining UIOP/CONFIGURATION:USER-CONFIGURATION-DIRECTORIES in DEFUN
WARNING: redefining UIOP/CONFIGURATION:SYSTEM-CONFIGURATION-DIRECTORIES in DEFUN
WARNING: redefining UIOP/CONFIGURATION:IN-FIRST-DIRECTORY in DEFUN
WARNING: redefining UIOP/CONFIGURATION:IN-USER-CONFIGURATION-DIRECTORY in DEFUN
WARNING: redefining UIOP/CONFIGURATION:IN-SYSTEM-CONFIGURATION-DIRECTORY in DEFUN
WARNING: redefining UIOP/BACKWARD-DRIVER:VERSION-COMPATIBLE-P in DEFUN
Unhandled UIOP/PACKAGE::NO-SUCH-PACKAGE-ERROR in thread #<SB-THREAD:THREAD tid=87480 "main thread" RUNNING {1200F10003}>: No package named STATISTICS-1

Backtrace for: #<SB-THREAD:THREAD tid=87480 "main thread" RUNNING {1200F10003}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<UIOP/PACKAGE::NO-SUCH-PACKAGE-ERROR expected-type: UIOP/PACKAGE::PACKAGE-DESIGNATOR datum: #:STATISTICS-1> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* #<UIOP/PACKAGE::NO-SUCH-PACKAGE-ERROR expected-type: UIOP/PACKAGE::PACKAGE-DESIGNATOR datum: #:STATISTICS-1>)
2: (INVOKE-DEBUGGER #<UIOP/PACKAGE::NO-SUCH-PACKAGE-ERROR expected-type: UIOP/PACKAGE::PACKAGE-DESIGNATOR datum: #:STATISTICS-1>)
3: (ERROR UIOP/PACKAGE::NO-SUCH-PACKAGE-ERROR :DATUM #:STATISTICS-1)
4: (UIOP/PACKAGE:FIND-PACKAGE* #:STATISTICS-1 (#:ADD #:MAKE-SPARSE-COUNTER #:WEIGHTED-QUANTILES))
5: (UIOP/PACKAGE:ENSURE-PACKAGE #:DATA-FRAME :NICKNAMES (#:DF) :DOCUMENTATION NIL :USE (#:CL #:ALEXANDRIA #:ALEXANDRIA+ #:ANAPHORA #:LET-PLUS #:SELECT #:SELECT-DEV) :SHADOW NIL :SHADOWING-IMPORT-FROM NIL :IMPORT-FROM ((#:NU #:AS-ALIST) (#:STATISTICS-1 #:ADD #:MAKE-SPARSE-COUNTER #:WEIGHTED-QUANTILES) (#:AOPS #:&DIMS #:LINSPACE)) :EXPORT (#:*LARGE-DATA* #:LARGE-DATA #:DUPLICATE-KEY #:KEY-NOT-FOUND #:DATA-TYPE #:COLUMNS #:MAP-COLUMNS #:COLUMN #:COLUMN-TYPE #:COLUMN-NAMES #:KEYS #:COPY ...) :INTERN NIL :RECYCLE (#:DATA-FRAME #:DF) :MIX NIL :REEXPORT NIL :UNINTERN NIL :LOCAL-NICKNAMES NIL)
6: ((LAMBDA NIL :IN "/home/quicklisp/quicklisp-controller/dist/build-cache/data-frame/d402bfb52ade94015f2af1168ccd59fbf9660c7f/data-frame-20250828-git/src/pkgdcl.lisp"))
7: (SB-INT:SIMPLE-EVAL-IN-LEXENV (LET ((#1=#:G0 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #:DATA-FRAME) :NICKNAMES (QUOTE #) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE #) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...))) (PROGN (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION (FIND-PACKAGE #)) (SB-C:SOURCE-LOCATION)) #1#)) #<NULL-LEXENV>)
8: (SB-INT:SIMPLE-EVAL-IN-LEXENV (PROGN (LET ((#1=#:G0 (FUNCALL # # :NICKNAMES # :DOCUMENTATION # :USE # :SHADOW # :SHADOWING-IMPORT-FROM ...))) (PROGN (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION #) (SB-C:SOURCE-LOCATION)) #1#))) #<NULL-LEXENV>)
9: (EVAL-TLF (PROGN (LET ((#1=#:G0 (FUNCALL # # :NICKNAMES # :DOCUMENTATION # :USE # :SHADOW # :SHADOWING-IMPORT-FROM ...))) (PROGN (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION #) (SB-C:SOURCE-LOCATION)) #1#))) 0 #<NULL-LEXENV>)
10: ((FLET SB-C::FROB :IN SB-C::EVAL-COMPILE-TOPLEVEL))
11: (SB-C::EVAL-COMPILE-TOPLEVEL ((LET ((#1=#:G0 (FUNCALL # # :NICKNAMES # :DOCUMENTATION # :USE # :SHADOW # :SHADOWING-IMPORT-FROM ...))) (PROGN (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION #) (SB-C:SOURCE-LOCATION)) #1#))) ((LET ((#1=#:G0 #2=(FUNCALL # # :NICKNAMES # :DOCUMENTATION # :USE # :SHADOW # :SHADOWING-IMPORT-FROM ...))) (PROGN #3=(SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION #) (SB-C:SOURCE-LOCATION)) #1#)) #4=(PROG1 #2# #3#) #5=(EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) #4#) (PROGN #5#) SB-C::ORIGINAL-SOURCE-START 0 0))
12: (SB-C::PROCESS-TOPLEVEL-FORM (LET ((#1=#:G0 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #:DATA-FRAME) :NICKNAMES (QUOTE #) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE #) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...))) (PROGN (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION (FIND-PACKAGE #)) (SB-C:SOURCE-LOCATION)) #1#)) (#1=(PROG1 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #:DATA-FRAME) :NICKNAMES (QUOTE (#:DF)) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE (#:CL #:ALEXANDRIA #:ALEXANDRIA+ #:ANAPHORA #:LET-PLUS #:SELECT #:SELECT-DEV)) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...) (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION (FIND-PACKAGE #)) (SB-C:SOURCE-LOCATION))) #2=(EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) #1#) (PROGN #2#) SB-C::ORIGINAL-SOURCE-START 0 0) (:COMPILE-TOPLEVEL))
13: (SB-C::PROCESS-TOPLEVEL-FORM (PROG1 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #1=#:DATA-FRAME) :NICKNAMES (QUOTE (#:DF)) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE (#:CL #:ALEXANDRIA #:ALEXANDRIA+ #:ANAPHORA #:LET-PLUS #:SELECT #:SELECT-DEV)) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...) (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION (FIND-PACKAGE (QUOTE #1#))) (SB-C:SOURCE-LOCATION))) (#1=(EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (PROG1 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #:DATA-FRAME) :NICKNAMES (QUOTE #) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE #) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...) (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION #) (SB-C:SOURCE-LOCATION)))) (PROGN #1#) SB-C::ORIGINAL-SOURCE-START 0 0) (:COMPILE-TOPLEVEL))
14: (SB-C::PROCESS-TOPLEVEL-PROGN ((PROG1 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #:DATA-FRAME) :NICKNAMES (QUOTE (#:DF)) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE (#:CL #:ALEXANDRIA #:ALEXANDRIA+ #:ANAPHORA #:LET-PLUS #:SELECT #:SELECT-DEV)) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...) (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION (FIND-PACKAGE #)) (SB-C:SOURCE-LOCATION)))) (#1=(EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (PROG1 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #:DATA-FRAME) :NICKNAMES (QUOTE #) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE #) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...) (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION #) (SB-C:SOURCE-LOCATION)))) (PROGN #1#) SB-C::ORIGINAL-SOURCE-START 0 0) (:COMPILE-TOPLEVEL))
15: (SB-C::PROCESS-TOPLEVEL-FORM (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (PROG1 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #:DATA-FRAME) :NICKNAMES (QUOTE (#:DF)) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE (#:CL #:ALEXANDRIA #:ALEXANDRIA+ #:ANAPHORA #:LET-PLUS #:SELECT #:SELECT-DEV)) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...) (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION (FIND-PACKAGE #)) (SB-C:SOURCE-LOCATION)))) ((PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (PROG1 (FUNCALL # # :NICKNAMES # :DOCUMENTATION # :USE # :SHADOW # :SHADOWING-IMPORT-FROM ...) (SETF # #)))) SB-C::ORIGINAL-SOURCE-START 0 0) NIL)
16: (SB-C::PROCESS-TOPLEVEL-PROGN ((EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (PROG1 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #:DATA-FRAME) :NICKNAMES (QUOTE #) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE #) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...) (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION #) (SB-C:SOURCE-LOCATION))))) ((PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (PROG1 (FUNCALL # # :NICKNAMES # :DOCUMENTATION # :USE # :SHADOW # :SHADOWING-IMPORT-FROM ...) (SETF # #)))) SB-C::ORIGINAL-SOURCE-START 0 0) NIL)
17: (SB-C::PROCESS-TOPLEVEL-FORM (PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (PROG1 (FUNCALL (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #:DATA-FRAME) :NICKNAMES (QUOTE #) :DOCUMENTATION (QUOTE NIL) :USE (QUOTE #) :SHADOW (QUOTE NIL) :SHADOWING-IMPORT-FROM ...) (SETF (SB-IMPL::PACKAGE-SOURCE-LOCATION #) (SB-C:SOURCE-LOCATION))))) (SB-C::ORIGINAL-SOURCE-START 0 0) NIL)
18: (SB-C::PROCESS-TOPLEVEL-FORM (UIOP/PACKAGE:DEFINE-PACKAGE #:DATA-FRAME (:NICKNAMES #:DF) (:USE #:CL #:ALEXANDRIA #:ALEXANDRIA+ #:ANAPHORA #:LET-PLUS #:SELECT #:SELECT-DEV) (:IMPORT-FROM #:NU #:AS-ALIST) (:IMPORT-FROM #:STATISTICS-1 #:ADD #:MAKE-SPARSE-COUNTER #:WEIGHTED-QUANTILES) (:IMPORT-FROM #:AOPS #:&DIMS #:LINSPACE) (:EXPORT #:*LARGE-DATA* #:LARGE-DATA #:DUPLICATE-KEY #:KEY-NOT-FOUND #:DATA-TYPE #:COLUMNS #:MAP-COLUMNS #:COLUMN #:COLUMN-TYPE #:COLUMN-NAMES #:KEYS ...)) (SB-C::ORIGINAL-SOURCE-START 0 0) NIL)
19: ((LAMBDA (SB-KERNEL:FORM &KEY :CURRENT-INDEX &ALLOW-OTHER-KEYS) :IN SB-C::SUB-COMPILE-FILE) (UIOP/PACKAGE:DEFINE-PACKAGE #:DATA-FRAME (:NICKNAMES #:DF) (:USE #:CL #:ALEXANDRIA #:ALEXANDRIA+ #:ANAPHORA #:LET-PLUS #:SELECT #:SELECT-DEV) (:IMPORT-FROM #:NU #:AS-ALIST) (:IMPORT-FROM #:STATISTICS-1 #:ADD #:MAKE-SPARSE-COUNTER #:WEIGHTED-QUANTILES) (:IMPORT-FROM #:AOPS #:&DIMS #:LINSPACE) (:EXPORT #:*LARGE-DATA* #:LARGE-DATA #:DUPLICATE-KEY #:KEY-NOT-FOUND #:DATA-TYPE #:COLUMNS #:MAP-COLUMNS #:COLUMN #:COLUMN-TYPE #:COLUMN-NAMES #:KEYS ...)) :CURRENT-INDEX 0)
20: (SB-C::%DO-FORMS-FROM-INFO #<FUNCTION (LAMBDA (SB-KERNEL:FORM &KEY :CURRENT-INDEX &ALLOW-OTHER-KEYS) :IN SB-C::SUB-COMPILE-FILE) {B8003A567B}> #<SB-C::SOURCE-INFO {12130A7DA3}> SB-C::INPUT-ERROR-IN-COMPILE-FILE)
21: ((LAMBDA NIL :IN SB-C::SUB-COMPILE-FILE))
22: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
23: (SB-C::SUB-COMPILE-FILE #<SB-C::SOURCE-INFO {12130A7DA3}> NIL)
24: (COMPILE-FILE #P"/home/quicklisp/quicklisp-controller/dist/build-cache/data-frame/d402bfb52ade94015f2af1168ccd59fbf9660c7f/data-frame-20250828-git/src/pkgdcl.lisp" :OUTPUT-FILE #P#<(SIMPLE-ARRAY CHARACTER (226)) /home/quicklisp/.cache/common-lisp/sbcl-2.5.7.135-b5e53e27e-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/data-frame/d402bfb52ade94015f2af1168ccd59fbf9660c7f/data-frame-20250828-git/s... {12131A974F}> :VERBOSE NIL :PRINT NIL :EXTERNAL-FORMAT :UTF-8 :PROGRESS NIL :TRACE-FILE NIL :BLOCK-COMPILE NIL :ENTRY-POINTS NIL :EMIT-CFASL NIL)
25: (UIOP/UTILITY:CALL-WITH-MUFFLED-CONDITIONS #<FUNCTION (LAMBDA NIL :IN UIOP/LISP-BUILD:COMPILE-FILE*) {121308688B}> NIL)
26: (UIOP/PATHNAME:CALL-WITH-ENOUGH-PATHNAME #P"/home/quicklisp/quicklisp-controller/dist/build-cache/data-frame/d402bfb52ade94015f2af1168ccd59fbf9660c7f/data-frame-20250828-git/src/pkgdcl.lisp" NIL #<FUNCTION (LAMBDA (UIOP/LISP-BUILD::INPUT-FILE) :IN UIOP/LISP-BUILD:COMPILE-FILE*) {121308680B}>)
27: (UIOP/LISP-BUILD:COMPILE-FILE* #P"/home/quicklisp/quicklisp-controller/dist/build-cache/data-frame/d402bfb52ade94015f2af1168ccd59fbf9660c7f/data-frame-20250828-git/src/pkgdcl.lisp" :OUTPUT-FILE #P#<(SIMPLE-ARRAY CHARACTER (214)) /home/quicklisp/.cache/common-lisp/sbcl-2.5.7.135-b5e53e27e-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/data-frame/d402bfb52ade94015f2af1168ccd59fbf9660c7f/data-frame-20250828-git/s... {12131B0F4F}> :EXTERNAL-FORMAT :UTF-8 :WARNINGS-FILE NIL)
28: (ASDF/LISP-ACTION:PERFORM-LISP-COMPILATION #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "data-frame" "pkgdcl">)
29: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "data-frame" "pkgdcl">)
30: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
31: ((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS :AROUND (T T)) #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "data-frame" "pkgdcl">) [fast-method]
32: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {12045EE2B3}>) [fast-method]
33: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
34: ((:METHOD ASDF/PLAN:PERFORM-PLAN :AROUND (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {12045EE2B3}>) [fast-method]
35: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "data-frame"> :PLAN-CLASS NIL :PLAN-OPTIONS NIL) [fast-method]
36: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "data-frame">)
37: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
38: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "data-frame">) [fast-method]
39: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "data-frame")
40: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
41: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "data-frame") [fast-method]
42: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {1204603A4B}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
43: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
44: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {12045C2A4B}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
45: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "data-frame") [fast-method]
46: (DEPCHECK::COMPUTE-DEPENDENCIES "data-frame" "data-frame")
47: (DEPCHECK::MAGIC "data-frame" "data-frame" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-n4vMwJ0r/depcheck-win.txt")
48: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "data-frame" "data-frame" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-n4vMwJ0r/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-n4vMwJ0r/depcheck-fail.txt"))
49: ((LAMBDA NIL :IN "/home/quicklisp/quicklisp/local-projects/quicklisp-controller/dumper-2SKVI5f7.lisp"))
50: ((FLET SB-UNIX::BODY :IN SB-IMPL::START-LISP))
51: ((FLET "WITHOUT-INTERRUPTS-BODY-3" :IN SB-IMPL::START-LISP))
52: (SB-IMPL::%START-LISP)

unhandled condition in --disable-debugger mode, quitting
; 
; compilation unit aborted
;   caught 2 fatal ERROR conditions