numcl

SBCL 2.0.2.97-9cd56b2cd / ASDF 3.3.1

numcl

WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-interpol/a82431c7ecb6a7c73f2ba9d4d18e23f65d0e3d0b/cl-interpol-20200317-git/cl-interpol.asd" contains definition for system "cl-interpol-test". Please only define "cl-interpol" and secondary systems with a name starting with "cl-interpol/" (e.g. "cl-interpol/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-ppcre/d6593d8f842bcf6af810ff93c6c02b757bd49ecf/cl-ppcre-20200317-git/cl-ppcre.asd" contains definition for system "cl-ppcre-test". Please only define "cl-ppcre" and secondary systems with a name starting with "cl-ppcre/" (e.g. "cl-ppcre/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/symbol-munger/a8589c60f470b8b280eacd9c983d96bc5f337341/symbol-munger-20200317-git/symbol-munger.asd" contains definition for system "symbol-munger-test". Please only define "symbol-munger" and secondary systems with a name starting with "symbol-munger/" (e.g. "symbol-munger/test") in that file.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/constantfold/378cbed129d745f65125c9f3931f350e92d61c22/constantfold-20200317-git/src/package.lisp
; in: DEFINE-NAMESPACE CONSTANT-FORM
;     (LISP-NAMESPACE:DEFINE-NAMESPACE CONSTANTFOLD::CONSTANT-FORM SYMBOL NIL
;                                      #<(SIMPLE-ARRAY CHARACTER
;                                         (324)) The namespace for user-defined constant forms. The value holds the copier name.
;   For a symbol X, a form (X ...) is considered as a constant form.
;   When the copier is NIL, the value (X ...) is evaluated ... {100775426F}>)
; --> EVAL-WHEN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CONSTANTFOLD::SYMBOL-CONSTANT-FORM
;         (SYMBOL &OPTIONAL
;          (LISP-NAMESPACE::DEFAULT NIL LISP-NAMESPACE::DEFAULT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       "Automatically defined getter function. When DEFAULT is supplied, the value is set automatically."
;       (BLOCK CONSTANTFOLD::SYMBOL-CONSTANT-FORM
;         (MULTIPLE-VALUE-BIND (LISP-NAMESPACE::VALUE LISP-NAMESPACE::FOUND)
;             (GETHASH SYMBOL CONSTANTFOLD::*CONSTANT-FORM-TABLE*)
;           (IF LISP-NAMESPACE::FOUND
;               LISP-NAMESPACE::VALUE
;               (IF LISP-NAMESPACE::DEFAULT-SUPPLIED-P
;                   #
;                   #)))))
; 
; note: type assertion too complex to check:
; (VALUES &OPTIONAL SYMBOL &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/constantfold/378cbed129d745f65125c9f3931f350e92d61c22/constantfold-20200317-git/src/package.lisp
; in: DEFUN CONSTANT-FORM-COPIER
;     (CONSTANTFOLD::SYMBOL-CONSTANT-FORM CONSTANTFOLD::NAME)
; 
; note: type assertion too complex to check:
; (VALUES &OPTIONAL SYMBOL &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/normal.lisp
; in: DEFUN RANDOM-NORMAL-ZIGGURAT
;     (< RANDOM-DISTRIBUTIONS::J
;        (AREF RANDOM-DISTRIBUTIONS::KTAB RANDOM-DISTRIBUTIONS::I))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (LOG RANDOM-DISTRIBUTIONS::U1)
; --> SB-KERNEL:%LOG BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "log" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (/ (- RANDOM-DISTRIBUTIONS::+R+ (LOG RANDOM-DISTRIBUTIONS::U1))
;        RANDOM-DISTRIBUTIONS::+R+)
; 
; note: unable to convert to multiplication by reciprocal because: 3.44428647676d0 does not have an exact reciprocal

;     (* RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::X)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (/ (* RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::X) 2)
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.

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

;     (EXP (- (/ (* RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::X) 2)))
; 
; 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.

;     (EXP
;      (-
;       (* RANDOM-DISTRIBUTIONS::+R+
;          (- RANDOM-DISTRIBUTIONS::X (/ RANDOM-DISTRIBUTIONS::+R+ 2)))))
; --> SB-KERNEL:%EXP BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

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

;     (LOGANDC2 (ASH RANDOM-DISTRIBUTIONS::I -6) 1)
; ==>
;   (LOGAND (ASH RANDOM-DISTRIBUTIONS::I -6) (LOGNOT 1))
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (- 1 (LOGANDC2 (ASH RANDOM-DISTRIBUTIONS::I -6) 1))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (FLOAT (- 1 (LOGANDC2 (ASH RANDOM-DISTRIBUTIONS::I -6) 1)) 1.0d0)
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::N)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).

;     (MOD RANDOM-DISTRIBUTIONS::I 128)
; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FLOOR 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE IF MINUSP 
; ==>
;   (< SB-C::X 0)
; 
; note: forced to do FAST-IF-<-ZERO (cost 9)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FLOOR 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF MINUSP 
; ==>
;   (< NUMBER 0)
; 
; note: forced to do FAST-IF-<-ZERO (cost 9)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (* RANDOM-DISTRIBUTIONS::J
;        (AREF RANDOM-DISTRIBUTIONS::WTAB RANDOM-DISTRIBUTIONS::I))
; 
; note: forced to do GENERIC-* (cost 30)
;       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 NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (< RANDOM-DISTRIBUTIONS::J
;        (AREF RANDOM-DISTRIBUTIONS::KTAB RANDOM-DISTRIBUTIONS::I))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.

;     (* RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::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 &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

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

;     (< RANDOM-DISTRIBUTIONS::Y
;        (EXP (- (/ (* RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::X) 2))))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The second argument is a (OR (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0) (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.

;     (* RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::SIGN)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (* RANDOM-DISTRIBUTIONS::SIGMA (RANDOM-DISTRIBUTIONS::N01))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).

;     (+ (* RANDOM-DISTRIBUTIONS::SIGMA (RANDOM-DISTRIBUTIONS::N01))
;        RANDOM-DISTRIBUTIONS::MEAN)
; 
; 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 result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).

;     (* RANDOM-DISTRIBUTIONS::J
;        (AREF RANDOM-DISTRIBUTIONS::WTAB RANDOM-DISTRIBUTIONS::I))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*

;     (LOG RANDOM-DISTRIBUTIONS::U1)
; --> SB-KERNEL:%LOG BLOCK TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN 
; --> SB-ALIEN-INTERNALS:%ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE 
; --> SB-ALIEN-INTERNALS:%SAP-ALIEN SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO 
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> SB-KERNEL:%LOG BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "log" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

;     (SETF RANDOM-DISTRIBUTIONS::X
;             (/ (- RANDOM-DISTRIBUTIONS::+R+ (LOG RANDOM-DISTRIBUTIONS::U1))
;                RANDOM-DISTRIBUTIONS::+R+)
;           RANDOM-DISTRIBUTIONS::Y (* (EXP (- #)) RANDOM-DISTRIBUTIONS::U2))
; --> PROGN SETF 
; ==>
;   (SETQ RANDOM-DISTRIBUTIONS::X
;           (/ (- RANDOM-DISTRIBUTIONS::+R+ (LOG RANDOM-DISTRIBUTIONS::U1))
;              RANDOM-DISTRIBUTIONS::+R+))
; 
; note: doing float to pointer coercion (cost 13) to X

;     (EXP
;      (-
;       (* RANDOM-DISTRIBUTIONS::+R+
;          (- RANDOM-DISTRIBUTIONS::X (/ RANDOM-DISTRIBUTIONS::+R+ 2)))))
; --> SB-KERNEL:%EXP BLOCK TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN 
; --> SB-ALIEN-INTERNALS:%ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE 
; --> SB-ALIEN-INTERNALS:%SAP-ALIEN SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO 
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> SB-KERNEL:%EXP BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

;     (< RANDOM-DISTRIBUTIONS::Y
;        (EXP (- (/ (* RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::X) 2))))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first argument of GENERIC-<

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/normal.lisp
; in: DEFUN RANDOM-NORMAL-BIVARIATE
;     (LOG RANDOM-DISTRIBUTIONS::RADIUS)
; --> SB-KERNEL:%LOG BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "log" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> SB-KERNEL:%LOG BLOCK TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN 
; --> SB-ALIEN-INTERNALS:%ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE 
; --> SB-ALIEN-INTERNALS:%SAP-ALIEN SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO 
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> SB-KERNEL:%LOG BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "log" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

;     (DEFUN RANDOM-DISTRIBUTIONS:RANDOM-NORMAL-BIVARIATE
;            (RANDOM-DISTRIBUTIONS::SIGMA-X RANDOM-DISTRIBUTIONS::SIGMA-Y
;             &KEY (RANDOM-DISTRIBUTIONS::RHO 0.0d0)
;             (RANDOM-DISTRIBUTIONS::ERROR-LIMIT 500))
;       #<(SIMPLE-ARRAY CHARACTER
;          (807)) Return a pair of numbers with specific correlation coefficent rho
;   and with specified variances sigma-x and sigma-y; a direct port of
;   gsl_ran_bivariate_gaussian from the GNU Scientific Library:
;   
;   void
;   g... {1009FAAE5F}>
;       (LET ((RANDOM-DISTRIBUTIONS::STATE *RANDOM-STATE*))
;         (LOOP RANDOM-DISTRIBUTIONS::REPEAT RANDOM-DISTRIBUTIONS::ERROR-LIMIT
;               DO (LET* (# # #)
;                    (WHEN # #))
;               RANDOM-DISTRIBUTIONS::FINALLY (ERROR
;                                              "Unsuccessful ~S after ~S tries."
;                                              'RANDOM-DISTRIBUTIONS:RANDOM-NORMAL-BIVARIATE
;                                              RANDOM-DISTRIBUTIONS::ERROR-LIMIT))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RANDOM-DISTRIBUTIONS:RANDOM-NORMAL-BIVARIATE
;         (RANDOM-DISTRIBUTIONS::SIGMA-X RANDOM-DISTRIBUTIONS::SIGMA-Y &KEY
;          (RANDOM-DISTRIBUTIONS::RHO 0.0d0)
;          (RANDOM-DISTRIBUTIONS::ERROR-LIMIT 500))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       #<(SIMPLE-ARRAY CHARACTER
;          (807)) Return a pair of numbers with specific correlation coefficent rho
; and with specified variances sigma-x and sigma-y; a direct port of
; gsl_ran_bivariate_gaussian from the GNU Scientific Library:
; 
; void
; g... {1009FAAE5F}>
;       (BLOCK RANDOM-DISTRIBUTIONS:RANDOM-NORMAL-BIVARIATE
;         (LET ((RANDOM-DISTRIBUTIONS::STATE *RANDOM-STATE*))
;           (LOOP RANDOM-DISTRIBUTIONS::REPEAT RANDOM-DISTRIBUTIONS::ERROR-LIMIT
;                 DO (LET* #
;                      #)
;                 RANDOM-DISTRIBUTIONS::FINALLY (ERROR
;                                                "Unsuccessful ~S after ~S tries."
;                                                'RANDOM-DISTRIBUTIONS:RANDOM-NORMAL-BIVARIATE
;                                                RANDOM-DISTRIBUTIONS::ERROR-LIMIT)))))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/gamma.lisp
; in: DEFUN GAMMA-LARGE
;     (SQRT (- (* 2 RANDOM-DISTRIBUTIONS::A) 1))
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (TAN (* PI (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM)))
; --> SB-KERNEL:%TAN BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "tan" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (LOG (/ RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::A-1))
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (EXP
;      (- (* RANDOM-DISTRIBUTIONS::A-1 (THE DOUBLE-FLOAT (LOG #)))
;         (* RANDOM-DISTRIBUTIONS::SQA RANDOM-DISTRIBUTIONS::Y)))
; --> SB-KERNEL:%EXP BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (LET* ((RANDOM-DISTRIBUTIONS::A-1 (- RANDOM-DISTRIBUTIONS::A 1.0d0))
;            (RANDOM-DISTRIBUTIONS::SQA (SQRT (- # 1)))
;            (RANDOM-DISTRIBUTIONS::X 0.0d0)
;            (RANDOM-DISTRIBUTIONS::Y 0.0d0)
;            (RANDOM-DISTRIBUTIONS::V 0.0d0))
;       (DECLARE
;        (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A-1 RANDOM-DISTRIBUTIONS::X
;         RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::V
;         RANDOM-DISTRIBUTIONS::SQA)
;        (DYNAMIC-EXTENT RANDOM-DISTRIBUTIONS::A-1 RANDOM-DISTRIBUTIONS::SQA
;         RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::V))
;       (TAGBODY
;        RANDOM-DISTRIBUTIONS::START
;         (SETQ RANDOM-DISTRIBUTIONS::Y (TAN #))
;         (SETQ RANDOM-DISTRIBUTIONS::X (+ # RANDOM-DISTRIBUTIONS::A-1))
;         (WHEN (<= RANDOM-DISTRIBUTIONS::X 0.0) (GO RANDOM-DISTRIBUTIONS::START))
;         (SETQ RANDOM-DISTRIBUTIONS::V (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM))
;         (WHEN (> RANDOM-DISTRIBUTIONS::V (* # #))
;           (GO RANDOM-DISTRIBUTIONS::START)))
;       RANDOM-DISTRIBUTIONS::X)
; --> MULTIPLE-VALUE-BIND LET VALUES PROG1 LET 
; ==>
;   #:G29
; 
; note: could not stack allocate #:G28 in: (LET* ((A-1 (- A 1.0d0)) (SQA (SQRT (- (* 2 A) 1))) (X 0.0d0) (Y 0.0d0) (V 0.0d0)) (DECLARE (DOUBLE-FLOAT A-1 X Y V SQA) (DYNAMIC-EXTENT A-1 SQA Y V)) (TAGBODY START (SETQ Y (TAN (* PI (RANDOM-UNIFORM)))) (SETQ X (+ (* SQA Y) A-1)) (WHEN (<= X 0.0) (GO START)) (SETQ V (RANDOM-UNIFORM)) (WHEN (> V (* (+ (* Y Y) 1.0d0) (EXP (- (* A-1 (THE DOUBLE-FLOAT (LOG (/ X A-1)))) (* SQA Y))))) (GO START))) X)

;     (- RANDOM-DISTRIBUTIONS::A 1.0d0)
; 
; note: could not stack allocate: (- A 1.0d0)

;     (SQRT (- (* 2 RANDOM-DISTRIBUTIONS::A) 1))
; 
; note: doing float to pointer coercion (cost 13)

;     (TAN (* PI (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM)))
; --> SB-KERNEL:%TAN BLOCK TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN 
; --> SB-ALIEN-INTERNALS:%ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE 
; --> SB-ALIEN-INTERNALS:%SAP-ALIEN SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO 
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> SB-KERNEL:%TAN BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "tan" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

;     (LOG (/ RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::A-1))
; 
; note: doing float to pointer coercion (cost 13)

;     (EXP
;      (- (* RANDOM-DISTRIBUTIONS::A-1 (THE DOUBLE-FLOAT (LOG #)))
;         (* RANDOM-DISTRIBUTIONS::SQA RANDOM-DISTRIBUTIONS::Y)))
; --> SB-KERNEL:%EXP BLOCK TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN 
; --> SB-ALIEN-INTERNALS:%ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE 
; --> SB-ALIEN-INTERNALS:%SAP-ALIEN SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO 
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> SB-KERNEL:%EXP BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

;     (DEFUN RANDOM-DISTRIBUTIONS::GAMMA-LARGE (RANDOM-DISTRIBUTIONS::A)
;       (DECLARE (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A))
;       (LET* ((RANDOM-DISTRIBUTIONS::A-1 (- RANDOM-DISTRIBUTIONS::A 1.0d0))
;              (RANDOM-DISTRIBUTIONS::SQA (SQRT #))
;              (RANDOM-DISTRIBUTIONS::X 0.0d0)
;              (RANDOM-DISTRIBUTIONS::Y 0.0d0)
;              (RANDOM-DISTRIBUTIONS::V 0.0d0))
;         (DECLARE
;          (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A-1 RANDOM-DISTRIBUTIONS::X
;           RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::V
;           RANDOM-DISTRIBUTIONS::SQA)
;          (DYNAMIC-EXTENT RANDOM-DISTRIBUTIONS::A-1 RANDOM-DISTRIBUTIONS::SQA
;           RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::V))
;         (TAGBODY
;          RANDOM-DISTRIBUTIONS::START
;           (SETQ RANDOM-DISTRIBUTIONS::Y #)
;           (SETQ RANDOM-DISTRIBUTIONS::X #)
;           (WHEN (<= RANDOM-DISTRIBUTIONS::X 0.0)
;             (GO RANDOM-DISTRIBUTIONS::START))
;           (SETQ RANDOM-DISTRIBUTIONS::V #)
;           (WHEN (> RANDOM-DISTRIBUTIONS::V #) (GO RANDOM-DISTRIBUTIONS::START)))
;         RANDOM-DISTRIBUTIONS::X))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RANDOM-DISTRIBUTIONS::GAMMA-LARGE
;         (RANDOM-DISTRIBUTIONS::A)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A))
;       (BLOCK RANDOM-DISTRIBUTIONS::GAMMA-LARGE
;         (LET* ((RANDOM-DISTRIBUTIONS::A-1 #)
;                (RANDOM-DISTRIBUTIONS::SQA #)
;                (RANDOM-DISTRIBUTIONS::X 0.0d0)
;                (RANDOM-DISTRIBUTIONS::Y 0.0d0)
;                (RANDOM-DISTRIBUTIONS::V 0.0d0))
;           (DECLARE
;            (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A-1 RANDOM-DISTRIBUTIONS::X
;             RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::V
;             RANDOM-DISTRIBUTIONS::SQA)
;            (DYNAMIC-EXTENT RANDOM-DISTRIBUTIONS::A-1 RANDOM-DISTRIBUTIONS::SQA
;             RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::V))
;           (TAGBODY
;            RANDOM-DISTRIBUTIONS::START
;             (SETQ #)
;             (SETQ #)
;             (WHEN # #)
;             (SETQ #)
;             (WHEN # #))
;           RANDOM-DISTRIBUTIONS::X)))
; 
; note: doing float to pointer coercion (cost 13) from X to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/gamma.lisp
; in: DEFUN RANDOM-GAMMA-INT
;     (LOG RANDOM-DISTRIBUTIONS::PROD)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (RANDOM-DISTRIBUTIONS::GAMMA-LARGE
;      (COERCE RANDOM-DISTRIBUTIONS::A 'DOUBLE-FLOAT))
; --> BLOCK LET* TAGBODY SETQ THE TAN SB-KERNEL:%TAN BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "tan" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET* TAGBODY WHEN IF > * EXP - * THE 
; ==>
;   (LOG (/ RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::A-1))
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES FLOAT &REST T).

; --> BLOCK LET* TAGBODY WHEN IF > * EXP SB-KERNEL:%EXP BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET* SQRT 
; ==>
;   (SB-KERNEL:%SQRT SB-C::X)
; 
; note: could not stack allocate: (GAMMA-LARGE (COERCE A (QUOTE DOUBLE-FLOAT)))

; --> BLOCK LET* 
; ==>
;   (- RANDOM-DISTRIBUTIONS::A 1.0d0)
; 
; note: could not stack allocate: (GAMMA-LARGE (COERCE A (QUOTE DOUBLE-FLOAT)))

;     (- (LOG RANDOM-DISTRIBUTIONS::PROD))
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (LOG RANDOM-DISTRIBUTIONS::PROD)))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) 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) &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (RANDOM-DISTRIBUTIONS::GAMMA-LARGE
;      (COERCE RANDOM-DISTRIBUTIONS::A 'DOUBLE-FLOAT))
; --> BLOCK LET* TAGBODY SETQ THE TAN SB-KERNEL:%TAN BLOCK TRULY-THE 
; --> ALIEN-FUNCALL EXTERN-ALIEN SB-ALIEN-INTERNALS:%ALIEN-VALUE 
; --> SB-ALIEN-INTERNALS:NATURALIZE SB-ALIEN-INTERNALS:%SAP-ALIEN 
; --> SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> BLOCK LET* TAGBODY SETQ THE TAN SB-KERNEL:%TAN BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "tan" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK LET* TAGBODY WHEN IF > * EXP - * THE 
; ==>
;   (LOG (/ RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::A-1))
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK LET* TAGBODY WHEN IF > * EXP SB-KERNEL:%EXP BLOCK TRULY-THE 
; --> ALIEN-FUNCALL EXTERN-ALIEN SB-ALIEN-INTERNALS:%ALIEN-VALUE 
; --> SB-ALIEN-INTERNALS:NATURALIZE SB-ALIEN-INTERNALS:%SAP-ALIEN 
; --> SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> BLOCK LET* TAGBODY WHEN IF > * EXP SB-KERNEL:%EXP BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK LET* 
; ==>
;   RANDOM-DISTRIBUTIONS::X
; 
; note: doing float to pointer coercion (cost 13) from X to "<return value>"

;     (LOG RANDOM-DISTRIBUTIONS::PROD)
; ==>
;   RANDOM-DISTRIBUTIONS::PROD
; 
; note: doing float to pointer coercion (cost 13) from PROD

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/gamma.lisp
; in: DEFUN GAMMA-FRAC
;     (LOG RANDOM-DISTRIBUTIONS::V)
; --> SB-KERNEL:%LOG BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "log" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (EXP (* (/ 1.0d0 RANDOM-DISTRIBUTIONS::A) (LOG RANDOM-DISTRIBUTIONS::V)))
; --> SB-KERNEL:%EXP BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (EXP (- RANDOM-DISTRIBUTIONS::X))
; --> SB-KERNEL:%EXP BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (LOG RANDOM-DISTRIBUTIONS::V)
; --> SB-KERNEL:%LOG BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "log" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (LOG RANDOM-DISTRIBUTIONS::X)
; --> SB-KERNEL:%LOG BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "log" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (EXP (* (- RANDOM-DISTRIBUTIONS::A 1.0d0) (LOG RANDOM-DISTRIBUTIONS::X)))
; --> SB-KERNEL:%EXP BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (SETF RANDOM-DISTRIBUTIONS::V (RANDOM-DISTRIBUTIONS::RANDOM-POS))
; ==>
;   (SETQ RANDOM-DISTRIBUTIONS::V (RANDOM-DISTRIBUTIONS::RANDOM-POS))
; 
; note: doing float to pointer coercion (cost 13) to V

;     (LOG RANDOM-DISTRIBUTIONS::V)
; --> SB-KERNEL:%LOG BLOCK TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN 
; --> SB-ALIEN-INTERNALS:%ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE 
; --> SB-ALIEN-INTERNALS:%SAP-ALIEN SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO 
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

;     (EXP (* (/ 1.0d0 RANDOM-DISTRIBUTIONS::A) (LOG RANDOM-DISTRIBUTIONS::V)))
; --> SB-KERNEL:%EXP BLOCK TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN 
; --> SB-ALIEN-INTERNALS:%ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE 
; --> SB-ALIEN-INTERNALS:%SAP-ALIEN SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO 
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> SB-KERNEL:%EXP BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

;     (EXP (- RANDOM-DISTRIBUTIONS::X))
; --> SB-KERNEL:%EXP BLOCK TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN 
; --> SB-ALIEN-INTERNALS:%ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE 
; --> SB-ALIEN-INTERNALS:%SAP-ALIEN SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO 
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> SB-KERNEL:%EXP BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

;     (LOG RANDOM-DISTRIBUTIONS::V)
; --> SB-KERNEL:%LOG BLOCK TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN 
; --> SB-ALIEN-INTERNALS:%ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE 
; --> SB-ALIEN-INTERNALS:%SAP-ALIEN SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO 
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

;     (SETF RANDOM-DISTRIBUTIONS::X (- 1.0d0 (LOG RANDOM-DISTRIBUTIONS::V)))
; ==>
;   (SETQ RANDOM-DISTRIBUTIONS::X (- 1.0d0 (LOG RANDOM-DISTRIBUTIONS::V)))
; 
; note: doing float to pointer coercion (cost 13) to X

;     (LOG RANDOM-DISTRIBUTIONS::X)
; --> SB-KERNEL:%LOG BLOCK TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN 
; --> SB-ALIEN-INTERNALS:%ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE 
; --> SB-ALIEN-INTERNALS:%SAP-ALIEN SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO 
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

;     (EXP (* (- RANDOM-DISTRIBUTIONS::A 1.0d0) (LOG RANDOM-DISTRIBUTIONS::X)))
; --> SB-KERNEL:%EXP BLOCK TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN 
; --> SB-ALIEN-INTERNALS:%ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE 
; --> SB-ALIEN-INTERNALS:%SAP-ALIEN SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO 
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> SB-KERNEL:%EXP BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/gamma.lisp
; in: DEFUN RANDOM-GAMMA1
;     (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT RANDOM-DISTRIBUTIONS::NA)
; --> BLOCK IF DO BLOCK LET TAGBODY RETURN-FROM PROGN - SB-KERNEL:%NEGATE THE 
; ==>
;   (LOG RANDOM-DISTRIBUTIONS::PROD)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (RANDOM-DISTRIBUTIONS::GAMMA-FRAC RANDOM-DISTRIBUTIONS::FRAC)
; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP * LOG SB-KERNEL:%LOG BLOCK 
; --> TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "log" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP SB-KERNEL:%EXP BLOCK 
; --> TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE - LOG SB-KERNEL:%LOG BLOCK 
; --> TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "log" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP * LOG SB-KERNEL:%LOG BLOCK 
; --> TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "log" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP SB-KERNEL:%EXP BLOCK 
; --> TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT RANDOM-DISTRIBUTIONS::NA)
; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY SETQ THE 
; --> TAN SB-KERNEL:%TAN BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "tan" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP - * THE 
; ==>
;   (LOG (/ RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::A-1))
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES FLOAT &REST T).

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP SB-KERNEL:%EXP BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK IF DO BLOCK LET TAGBODY RETURN-FROM PROGN - SB-KERNEL:%NEGATE THE 
; ==>
;   (LOG RANDOM-DISTRIBUTIONS::PROD)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES FLOAT &REST T).

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY SETQ THE 
; --> TAN SB-KERNEL:%TAN BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "tan" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP - * THE 
; ==>
;   (LOG (/ RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::A-1))
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES FLOAT &REST T).

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP SB-KERNEL:%EXP BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (RANDOM-DISTRIBUTIONS::GAMMA-FRAC RANDOM-DISTRIBUTIONS::A)
; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP * LOG SB-KERNEL:%LOG BLOCK 
; --> TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "log" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP SB-KERNEL:%EXP BLOCK 
; --> TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE - LOG SB-KERNEL:%LOG BLOCK 
; --> TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "log" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP * LOG SB-KERNEL:%LOG BLOCK 
; --> TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "log" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP SB-KERNEL:%EXP BLOCK 
; --> TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT RANDOM-DISTRIBUTIONS::NA)
; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* SQRT 
; ==>
;   (SB-KERNEL:%SQRT SB-C::X)
; 
; note: could not stack allocate: (RANDOM-GAMMA-INT NA)

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* 
; ==>
;   (- RANDOM-DISTRIBUTIONS::A 1.0d0)
; 
; note: could not stack allocate: (RANDOM-GAMMA-INT NA)

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* SQRT 
; ==>
;   (SB-KERNEL:%SQRT SB-C::X)
; 
; note: could not stack allocate: (RANDOM-GAMMA-INT NA)

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* 
; ==>
;   (- RANDOM-DISTRIBUTIONS::A 1.0d0)
; 
; note: could not stack allocate: (RANDOM-GAMMA-INT NA)

;     (TRUNCATE RANDOM-DISTRIBUTIONS::A)
; --> TRUNCATE LET 
; ==>
;   (SB-KERNEL:%UNARY-TRUNCATE/DOUBLE-FLOAT SB-C::X)
; 
; note: could not stack allocate: (TRUNCATE A)

; --> TRUNCATE LET VALUES 
; ==>
;   (- SB-C::X
;      (LOCALLY
;       (DECLARE (SB-ASSEM:FLUSHABLE SB-KERNEL:%DOUBLE-FLOAT))
;       (SB-KERNEL:%DOUBLE-FLOAT SB-C::RES)))
; 
; note: could not stack allocate: (TRUNCATE A)

; --> TRUNCATE LET 
; ==>
;   (SB-KERNEL:%UNARY-TRUNCATE/DOUBLE-FLOAT SB-C::X)
; 
; note: forced to do full call
;       unable to do inline float truncate (cost 5) because:
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

; --> TRUNCATE LET VALUES - LOCALLY 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::RES)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).

;     (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT RANDOM-DISTRIBUTIONS::NA)
; --> BLOCK IF DO BLOCK LET TAGBODY RETURN-FROM PROGN - 
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (LOG RANDOM-DISTRIBUTIONS::PROD)))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) 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) &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) 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) &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (+ (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT RANDOM-DISTRIBUTIONS::NA)
;        (RANDOM-DISTRIBUTIONS::GAMMA-FRAC RANDOM-DISTRIBUTIONS::FRAC))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) 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) &REST T).

;     (* RANDOM-DISTRIBUTIONS::B
;        (+ (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT RANDOM-DISTRIBUTIONS::NA)
;           (RANDOM-DISTRIBUTIONS::GAMMA-FRAC RANDOM-DISTRIBUTIONS::FRAC)))
; 
; 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 DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       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 (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).

;     (RANDOM-DISTRIBUTIONS::GAMMA-FRAC RANDOM-DISTRIBUTIONS::A)
; --> BLOCK LET TAGBODY SETF 
; ==>
;   (SETQ RANDOM-DISTRIBUTIONS::V (RANDOM-DISTRIBUTIONS::RANDOM-POS))
; 
; note: doing float to pointer coercion (cost 13) to V

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP * LOG SB-KERNEL:%LOG BLOCK 
; --> TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN SB-ALIEN-INTERNALS:%ALIEN-VALUE 
; --> SB-ALIEN-INTERNALS:NATURALIZE SB-ALIEN-INTERNALS:%SAP-ALIEN 
; --> SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP SB-KERNEL:%EXP BLOCK 
; --> TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN SB-ALIEN-INTERNALS:%ALIEN-VALUE 
; --> SB-ALIEN-INTERNALS:NATURALIZE SB-ALIEN-INTERNALS:%SAP-ALIEN 
; --> SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP SB-KERNEL:%EXP BLOCK 
; --> TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP SB-KERNEL:%EXP BLOCK 
; --> TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN SB-ALIEN-INTERNALS:%ALIEN-VALUE 
; --> SB-ALIEN-INTERNALS:NATURALIZE SB-ALIEN-INTERNALS:%SAP-ALIEN 
; --> SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP SB-KERNEL:%EXP BLOCK 
; --> TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

;     (DEFUN RANDOM-DISTRIBUTIONS:RANDOM-GAMMA1
;            (RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B)
;       #<(SIMPLE-ARRAY CHARACTER
;          (576)) The Gamma distribution of order a>0 is defined by:
;   
;     p(x) dx = {1 / Gamma(a) b^a } x^{a-1} e^{-x/b} dx
;   
;     for x>0.  If X and Y are independent gamma-distributed random
;     variables of order a1 and a2 ... {100AFF9AFF}>
;       (DECLARE (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B))
;       (ASSERT (> RANDOM-DISTRIBUTIONS::A 0.0d0))
;       (MULTIPLE-VALUE-BIND (RANDOM-DISTRIBUTIONS::NA RANDOM-DISTRIBUTIONS::FRAC)
;           (TRUNCATE RANDOM-DISTRIBUTIONS::A)
;         (DECLARE
;          (DYNAMIC-EXTENT RANDOM-DISTRIBUTIONS::NA RANDOM-DISTRIBUTIONS::FRAC))
;         (IF (= RANDOM-DISTRIBUTIONS::FRAC 0)
;             (* RANDOM-DISTRIBUTIONS::B
;                (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT RANDOM-DISTRIBUTIONS::NA))
;             (IF (= RANDOM-DISTRIBUTIONS::NA 0)
;                 (* RANDOM-DISTRIBUTIONS::B #)
;                 (* RANDOM-DISTRIBUTIONS::B #)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RANDOM-DISTRIBUTIONS:RANDOM-GAMMA1
;         (RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       #<(SIMPLE-ARRAY CHARACTER
;          (576)) The Gamma distribution of order a>0 is defined by:
; 
;   p(x) dx = {1 / Gamma(a) b^a } x^{a-1} e^{-x/b} dx
; 
;   for x>0.  If X and Y are independent gamma-distributed random
;   variables of order a1 and a2 ... {100AFF9AFF}>
;       (DECLARE (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B))
;       (BLOCK RANDOM-DISTRIBUTIONS:RANDOM-GAMMA1
;         (ASSERT (> RANDOM-DISTRIBUTIONS::A 0.0d0))
;         (MULTIPLE-VALUE-BIND
;             (RANDOM-DISTRIBUTIONS::NA RANDOM-DISTRIBUTIONS::FRAC)
;             (TRUNCATE RANDOM-DISTRIBUTIONS::A)
;           (DECLARE
;            (DYNAMIC-EXTENT RANDOM-DISTRIBUTIONS::NA
;             RANDOM-DISTRIBUTIONS::FRAC))
;           (IF (= RANDOM-DISTRIBUTIONS::FRAC 0)
;               (* RANDOM-DISTRIBUTIONS::B #)
;               (IF #
;                   #
;                   #)))))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

;     (RANDOM-DISTRIBUTIONS::GAMMA-FRAC RANDOM-DISTRIBUTIONS::A)
; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE - LOG SB-KERNEL:%LOG BLOCK 
; --> TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN SB-ALIEN-INTERNALS:%ALIEN-VALUE 
; --> SB-ALIEN-INTERNALS:NATURALIZE SB-ALIEN-INTERNALS:%SAP-ALIEN 
; --> SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP * LOG 
; ==>
;   RANDOM-DISTRIBUTIONS::X
; 
; note: doing float to pointer coercion (cost 13) from X

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP * LOG SB-KERNEL:%LOG BLOCK 
; --> TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN SB-ALIEN-INTERNALS:%ALIEN-VALUE 
; --> SB-ALIEN-INTERNALS:NATURALIZE SB-ALIEN-INTERNALS:%SAP-ALIEN 
; --> SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP SB-KERNEL:%EXP BLOCK 
; --> TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN SB-ALIEN-INTERNALS:%ALIEN-VALUE 
; --> SB-ALIEN-INTERNALS:NATURALIZE SB-ALIEN-INTERNALS:%SAP-ALIEN 
; --> SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP SB-KERNEL:%EXP BLOCK 
; --> TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

;     (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT RANDOM-DISTRIBUTIONS::NA)
; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY SETQ THE 
; --> TAN SB-KERNEL:%TAN BLOCK TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN 
; --> SB-ALIEN-INTERNALS:%ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE 
; --> SB-ALIEN-INTERNALS:%SAP-ALIEN SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO 
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY SETQ THE 
; --> TAN SB-KERNEL:%TAN BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "tan" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP - * THE 
; ==>
;   (LOG (/ RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::A-1))
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP SB-KERNEL:%EXP BLOCK TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN 
; --> SB-ALIEN-INTERNALS:%ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE 
; --> SB-ALIEN-INTERNALS:%SAP-ALIEN SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO 
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP SB-KERNEL:%EXP BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* 
; ==>
;   RANDOM-DISTRIBUTIONS::X
; 
; note: doing float to pointer coercion (cost 13) from X

;     (RANDOM-DISTRIBUTIONS::GAMMA-FRAC RANDOM-DISTRIBUTIONS::FRAC)
; --> BLOCK LET TAGBODY SETF 
; ==>
;   (SETQ RANDOM-DISTRIBUTIONS::V (RANDOM-DISTRIBUTIONS::RANDOM-POS))
; 
; note: doing float to pointer coercion (cost 13) to V

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP * LOG SB-KERNEL:%LOG BLOCK 
; --> TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN SB-ALIEN-INTERNALS:%ALIEN-VALUE 
; --> SB-ALIEN-INTERNALS:NATURALIZE SB-ALIEN-INTERNALS:%SAP-ALIEN 
; --> SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP SB-KERNEL:%EXP BLOCK 
; --> TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN SB-ALIEN-INTERNALS:%ALIEN-VALUE 
; --> SB-ALIEN-INTERNALS:NATURALIZE SB-ALIEN-INTERNALS:%SAP-ALIEN 
; --> SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP SB-KERNEL:%EXP BLOCK 
; --> TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP SB-KERNEL:%EXP BLOCK 
; --> TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN SB-ALIEN-INTERNALS:%ALIEN-VALUE 
; --> SB-ALIEN-INTERNALS:NATURALIZE SB-ALIEN-INTERNALS:%SAP-ALIEN 
; --> SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP SB-KERNEL:%EXP BLOCK 
; --> TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE - LOG SB-KERNEL:%LOG BLOCK 
; --> TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN SB-ALIEN-INTERNALS:%ALIEN-VALUE 
; --> SB-ALIEN-INTERNALS:NATURALIZE SB-ALIEN-INTERNALS:%SAP-ALIEN 
; --> SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> BLOCK LET TAGBODY IF PROGN SETF 
; ==>
;   (SETQ RANDOM-DISTRIBUTIONS::X (- 1.0d0 (LOG RANDOM-DISTRIBUTIONS::V)))
; 
; note: doing float to pointer coercion (cost 13) to X

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP * LOG SB-KERNEL:%LOG BLOCK 
; --> TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN SB-ALIEN-INTERNALS:%ALIEN-VALUE 
; --> SB-ALIEN-INTERNALS:NATURALIZE SB-ALIEN-INTERNALS:%SAP-ALIEN 
; --> SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP SB-KERNEL:%EXP BLOCK 
; --> TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN SB-ALIEN-INTERNALS:%ALIEN-VALUE 
; --> SB-ALIEN-INTERNALS:NATURALIZE SB-ALIEN-INTERNALS:%SAP-ALIEN 
; --> SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP SB-KERNEL:%EXP BLOCK 
; --> TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

;     (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT RANDOM-DISTRIBUTIONS::NA)
; --> BLOCK IF DO BLOCK LET TAGBODY RETURN-FROM PROGN - SB-KERNEL:%NEGATE THE 
; --> LOG 
; ==>
;   RANDOM-DISTRIBUTIONS::PROD
; 
; note: doing float to pointer coercion (cost 13) from PROD

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY SETQ THE 
; --> TAN SB-KERNEL:%TAN BLOCK TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN 
; --> SB-ALIEN-INTERNALS:%ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE 
; --> SB-ALIEN-INTERNALS:%SAP-ALIEN SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO 
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY SETQ THE 
; --> TAN SB-KERNEL:%TAN BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "tan" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP - * THE 
; ==>
;   (LOG (/ RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::A-1))
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP SB-KERNEL:%EXP BLOCK TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN 
; --> SB-ALIEN-INTERNALS:%ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE 
; --> SB-ALIEN-INTERNALS:%SAP-ALIEN SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO 
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP SB-KERNEL:%EXP BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "exp" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK IF DO BLOCK LET TAGBODY RETURN-FROM PROGN - SB-KERNEL:%NEGATE THE 
; --> LOG 
; ==>
;   RANDOM-DISTRIBUTIONS::PROD
; 
; note: doing float to pointer coercion (cost 13) from PROD

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/gamma.lisp
; in: DEFUN RANDOM-GAMMA-MT
;     (EXPT (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM) (/ RANDOM-DISTRIBUTIONS::A))
; --> SB-KERNEL:%POW BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL
;    (EXTERN-ALIEN "pow" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT DOUBLE-FLOAT))
;    SB-KERNEL::ARG0 SB-KERNEL::ARG1)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (LOG RANDOM-DISTRIBUTIONS::U)
; --> SB-KERNEL:%LOG BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL (EXTERN-ALIEN "log" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT))
;                  SB-KERNEL::ARG0)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (LOG RANDOM-DISTRIBUTIONS::V)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (LOG RANDOM-DISTRIBUTIONS::U)
; ==>
;   RANDOM-DISTRIBUTIONS::U
; 
; note: doing float to pointer coercion (cost 13) from U

; --> SB-KERNEL:%LOG BLOCK TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN 
; --> SB-ALIEN-INTERNALS:%ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE 
; --> SB-ALIEN-INTERNALS:%SAP-ALIEN SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO 
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

;     (LOG RANDOM-DISTRIBUTIONS::V)
; ==>
;   RANDOM-DISTRIBUTIONS::V
; 
; note: doing float to pointer coercion (cost 13) from V

;     (DEFUN RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-MT
;            (RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B)
;       "New version based on Marsaglia and Tsang, 'A Simple Method for
;   generating gamma variables', ACM Transactions on Mathematical
;   Software, Vol 26, No 3 (2000), p363-372."
;       (DECLARE (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B))
;       (IF (< RANDOM-DISTRIBUTIONS::A 1.0d0)
;           (*
;            (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-MT
;             (+ 1.0d0 RANDOM-DISTRIBUTIONS::A) RANDOM-DISTRIBUTIONS::B)
;            (EXPT (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM)
;                  (/ RANDOM-DISTRIBUTIONS::A)))
;           (LET* ((RANDOM-DISTRIBUTIONS::X 0.0d0)
;                  (RANDOM-DISTRIBUTIONS::V 0.0d0)
;                  (RANDOM-DISTRIBUTIONS::U 0.0d0)
;                  (RANDOM-DISTRIBUTIONS::D #)
;                  (RANDOM-DISTRIBUTIONS::C #))
;             (DECLARE
;              (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::V
;               RANDOM-DISTRIBUTIONS::U RANDOM-DISTRIBUTIONS::D
;               RANDOM-DISTRIBUTIONS::C))
;             (TAGBODY
;              RANDOM-DISTRIBUTIONS::START
;               (SETF #)
;               (SETF #)
;               (WHEN # #)
;               (SETF #)
;               (SETF #)
;               (WHEN # #)
;               (WHEN # #)
;               (GO RANDOM-DISTRIBUTIONS::START)
;              RANDOM-DISTRIBUTIONS::END)
;             (* RANDOM-DISTRIBUTIONS::B RANDOM-DISTRIBUTIONS::D
;                RANDOM-DISTRIBUTIONS::V))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-MT
;         (RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       "New version based on Marsaglia and Tsang, 'A Simple Method for
; generating gamma variables', ACM Transactions on Mathematical
; Software, Vol 26, No 3 (2000), p363-372."
;       (DECLARE (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B))
;       (BLOCK RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-MT
;         (IF (< RANDOM-DISTRIBUTIONS::A 1.0d0)
;             (* (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-MT # RANDOM-DISTRIBUTIONS::B)
;                (EXPT # #))
;             (LET* (# # # # #)
;               (DECLARE #)
;               (TAGBODY
;                RANDOM-DISTRIBUTIONS::START
;                 #
;                 #
;                 #
;                 #
;                 #
;                 #
;                 #
;                 #
;                RANDOM-DISTRIBUTIONS::END)
;               (* RANDOM-DISTRIBUTIONS::B RANDOM-DISTRIBUTIONS::D
;                  RANDOM-DISTRIBUTIONS::V)))))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

;     (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM)
; --> BLOCK RANDOM 
; ==>
;   (SB-KERNEL:%RANDOM-DOUBLE-FLOAT SB-C::NUM (OR SB-C::STATE *RANDOM-STATE*))
; 
; note: doing float to pointer coercion (cost 13)

;     (EXPT (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM) (/ RANDOM-DISTRIBUTIONS::A))
; --> SB-KERNEL:%POW BLOCK TRULY-THE ALIEN-FUNCALL EXTERN-ALIEN 
; --> SB-ALIEN-INTERNALS:%ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE 
; --> SB-ALIEN-INTERNALS:%SAP-ALIEN SB-KERNEL::%MAKE-STRUCTURE-INSTANCE-MACRO 
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAKE-STRUCTURE-INSTANCE
;    #<SB-KERNEL:DEFSTRUCT-DESCRIPTION SB-ALIEN-INTERNALS:ALIEN-VALUE {1000005893}>
;    '((:SLOT T . 0) (:SLOT T . 1)) (THE SYSTEM-AREA-POINTER SB-KERNEL::SAP)
;    (THE SB-ALIEN-INTERNALS:ALIEN-TYPE TYPE))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of INIT-SLOT

; --> SB-KERNEL:%POW BLOCK TRULY-THE 
; ==>
;   (ALIEN-FUNCALL
;    (EXTERN-ALIEN "pow" (FUNCTION DOUBLE-FLOAT DOUBLE-FLOAT DOUBLE-FLOAT))
;    SB-KERNEL::ARG0 SB-KERNEL::ARG1)
; 
; note: doing float to pointer coercion (cost 13)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/binomial.lisp
; in: DEFUN RANDOM-BINOMIAL
;     (<= RANDOM-DISTRIBUTIONS::N 10)
; --> IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLOOR RANDOM-DISTRIBUTIONS::N 2)
; --> LET VALUES 
; ==>
;   (ASH SB-C::X -1)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (INTEGER 11), not a FIXNUM.
;       The result is a (VALUES (INTEGER 5) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER 11), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER 5) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.

;     (+ 1 (FLOOR RANDOM-DISTRIBUTIONS::N 2))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER 5), not a FIXNUM.
;       The result is a (VALUES (INTEGER 6) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 5), not a FIXNUM.
;       The result is a (VALUES (INTEGER 6) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::N RANDOM-DISTRIBUTIONS::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 11), not a FIXNUM.
;       The second argument is a (INTEGER 6), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 11), not a (SIGNED-BYTE 64).
;       The second argument is a (INTEGER 6), not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (+ 1 (- RANDOM-DISTRIBUTIONS::N RANDOM-DISTRIBUTIONS::A))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (COERCE RANDOM-DISTRIBUTIONS::A 'DOUBLE-FLOAT)
; --> THE 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::X)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (INTEGER 6), not a (SIGNED-BYTE 64).

;     (COERCE RANDOM-DISTRIBUTIONS::B 'DOUBLE-FLOAT)
; --> THE 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::X)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).

;     (- RANDOM-DISTRIBUTIONS::A 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER 6), not a FIXNUM.
;       The result is a (VALUES (INTEGER 5) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 6), not a FIXNUM.
;       The result is a (VALUES (INTEGER 5) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (INCF RANDOM-DISTRIBUTIONS::K RANDOM-DISTRIBUTIONS::A)
; --> SETQ THE 
; ==>
;   (+ RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::K)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 6), not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 6), not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::B 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::N 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER * 10), not a FIXNUM.
;       The result is a (VALUES (INTEGER * 9) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER * 10), not a FIXNUM.
;       The result is a (VALUES (INTEGER * 9) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::I INTEGER RANDOM-DISTRIBUTIONS::FROM 0 RANDOM-DISTRIBUTIONS::TO (-
;                                                                                                                            RANDOM-DISTRIBUTIONS::N
;                                                                                                                            1)
;           RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::U = (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM) ...)
; --> BLOCK LET LET TAGBODY WHEN IF 
; ==>
;   (> RANDOM-DISTRIBUTIONS::I #:LOOP-LIMIT-0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a (INTEGER * 9), not a FIXNUM.

;     (INCF RANDOM-DISTRIBUTIONS::K)
; --> SETQ THE 
; ==>
;   (+ 1 RANDOM-DISTRIBUTIONS::K)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::I INTEGER RANDOM-DISTRIBUTIONS::FROM 0 RANDOM-DISTRIBUTIONS::TO (-
;                                                                                                                            RANDOM-DISTRIBUTIONS::N
;                                                                                                                            1)
;           RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::U = (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM) ...)
; --> BLOCK LET LET TAGBODY SB-LOOP::LOOP-DESETQ 
; ==>
;   (SETQ RANDOM-DISTRIBUTIONS::U (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM))
; 
; note: doing float to pointer coercion (cost 13) to U

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/poisson.lisp
; in: DEFUN RANDOM-POISSON
;     (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT RANDOM-DISTRIBUTIONS::M)
; --> BLOCK IF DO BLOCK LET TAGBODY RETURN-FROM PROGN - SB-KERNEL:%NEGATE THE 
; ==>
;   (LOG RANDOM-DISTRIBUTIONS::PROD)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES FLOAT &REST T).

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP - * THE 
; ==>
;   (LOG (/ RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::A-1))
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES FLOAT &REST T).

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* SQRT 
; ==>
;   (SB-KERNEL:%SQRT SB-C::X)
; 
; note: could not stack allocate: (RANDOM-GAMMA-INT M)

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* 
; ==>
;   (- RANDOM-DISTRIBUTIONS::A 1.0d0)
; 
; note: could not stack allocate: (RANDOM-GAMMA-INT M)

;     (TRUNCATE (* RANDOM-DISTRIBUTIONS::MU (/ 7.0d0 8.0d0)))
; --> TRUNCATE LET 
; ==>
;   (SB-KERNEL:%UNARY-TRUNCATE/DOUBLE-FLOAT SB-C::X)
; 
; note: forced to do full call
;       unable to do inline float truncate (cost 5) because:
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

;     (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT RANDOM-DISTRIBUTIONS::M)
; --> BLOCK IF DO BLOCK LET TAGBODY RETURN-FROM PROGN - 
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (LOG RANDOM-DISTRIBUTIONS::PROD)))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) 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) &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (+ RANDOM-DISTRIBUTIONS::K
;        (TRUNCATE
;         (RANDOM-DISTRIBUTIONS:RANDOM-BINOMIAL
;          (/ RANDOM-DISTRIBUTIONS::MU RANDOM-DISTRIBUTIONS::X)
;          (- RANDOM-DISTRIBUTIONS::M 1))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (INCF RANDOM-DISTRIBUTIONS::K RANDOM-DISTRIBUTIONS::M)
; --> SETQ THE 
; ==>
;   (+ RANDOM-DISTRIBUTIONS::M RANDOM-DISTRIBUTIONS::K)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (INCF RANDOM-DISTRIBUTIONS::K)
; --> SETQ THE 
; ==>
;   (+ 1 RANDOM-DISTRIBUTIONS::K)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

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

;     (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT RANDOM-DISTRIBUTIONS::M)
; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP - * THE 
; ==>
;   (LOG (/ RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::A-1))
; 
; note: doing float to pointer coercion (cost 13)

;     (TRUNCATE (* RANDOM-DISTRIBUTIONS::MU (/ 7.0d0 8.0d0)))
; --> TRUNCATE LET 
; ==>
;   (SB-KERNEL:%UNARY-TRUNCATE/DOUBLE-FLOAT SB-C::X)
; 
; note: doing float to pointer coercion (cost 13)

;     (RANDOM-DISTRIBUTIONS:RANDOM-BINOMIAL
;      (/ RANDOM-DISTRIBUTIONS::MU RANDOM-DISTRIBUTIONS::X)
;      (- RANDOM-DISTRIBUTIONS::M 1))
; 
; note: doing float to pointer coercion (cost 13)

;     (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT RANDOM-DISTRIBUTIONS::M)
; --> BLOCK IF DO BLOCK LET TAGBODY RETURN-FROM PROGN - SB-KERNEL:%NEGATE THE 
; --> LOG 
; ==>
;   RANDOM-DISTRIBUTIONS::PROD
; 
; note: doing float to pointer coercion (cost 13) from PROD

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/nbinomial.lisp
; in: DEFUN RANDOM-NEGATIVE-BINOMIAL
;     (COERCE RANDOM-DISTRIBUTIONS::N 'DOUBLE-FLOAT)
; --> THE 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::X)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).

;     (* RANDOM-DISTRIBUTIONS::X
;        (/ (- 1.0d0 RANDOM-DISTRIBUTIONS::P) RANDOM-DISTRIBUTIONS::P))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first result of inline float arithmetic

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/multinomial.lisp
; in: DEFUN RANDOM-MULTINOMIAL1
;     (ARRAY-DIMENSION RANDOM-DISTRIBUTIONS::P 0)
; 
; note: unable to optimize because: The array dimensions are unknown; must call ARRAY-DIMENSION at runtime.

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

;     (> (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::I) 0.0d0)
; 
; note: unable to open-code RATIONAL to FLOAT comparison due to type uncertainty: The first argument is a REAL, not a RATIONAL.

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

;     (/ (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::I)
;        (- RANDOM-DISTRIBUTIONS::NORM RANDOM-DISTRIBUTIONS::SUM-P))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (SETF (AREF RANDOM-DISTRIBUTIONS::N RANDOM-DISTRIBUTIONS::I)
;             (IF (> (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::I) 0.0d0)
;                 (RANDOM-DISTRIBUTIONS:RANDOM-BINOMIAL (/ # #)
;                                                       (- RANDOM-DISTRIBUTIONS::NN
;                                                          RANDOM-DISTRIBUTIONS::SUM-N))
;                 0))
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS ARRAY SB-INT:INDEX
;                                                 SB-C::NEW-VALUE)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

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

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

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

;     (LOOP RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::I FIXNUM RANDOM-DISTRIBUTIONS::FROM 0 RANDOM-DISTRIBUTIONS::TO RANDOM-DISTRIBUTIONS::K
;           RANDOM-DISTRIBUTIONS::SUM (AREF RANDOM-DISTRIBUTIONS::P
;                                           RANDOM-DISTRIBUTIONS::I))
; --> BLOCK LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-1 (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::I))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (> (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::I) 0.0d0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a DOUBLE-FLOAT.

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

;     (/ (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::I)
;        (- RANDOM-DISTRIBUTIONS::NORM RANDOM-DISTRIBUTIONS::SUM-P))
; 
; 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 &REST T).
;       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) &REST T).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::NN RANDOM-DISTRIBUTIONS::SUM-N)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (LOOP RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::I RANDOM-DISTRIBUTIONS::FROM 0 RANDOM-DISTRIBUTIONS::TO RANDOM-DISTRIBUTIONS::K
;           DO (PROGN
;               (SETF (AREF RANDOM-DISTRIBUTIONS::N RANDOM-DISTRIBUTIONS::I)
;                       (IF #
;                           #
;                           0)))
;           RANDOM-DISTRIBUTIONS::SUM (AREF RANDOM-DISTRIBUTIONS::P
;                                           RANDOM-DISTRIBUTIONS::I) RANDOM-DISTRIBUTIONS::INTO ...)
; --> BLOCK LET SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY 
; --> SETQ THE 
; ==>
;   (+ RANDOM-DISTRIBUTIONS::SUM-P
;      (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::I))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; ==>
;   (+ RANDOM-DISTRIBUTIONS::SUM-N
;      (AREF RANDOM-DISTRIBUTIONS::N RANDOM-DISTRIBUTIONS::I))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/multinomial.lisp
; in: DEFUN CONVERT-TO-DOUBLE-FLOAT-VECTOR
;     (MAP 'VECTOR
;          (LAMBDA (RANDOM-DISTRIBUTIONS::X)
;            (COERCE RANDOM-DISTRIBUTIONS::X 'DOUBLE-FLOAT))
;          RANDOM-DISTRIBUTIONS::X)
; --> TRULY-THE SB-KERNEL:%MAP MAP-INTO MAKE-SEQUENCE MIN LET 
; ==>
;   (LENGTH #:G5)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (COERCE RANDOM-DISTRIBUTIONS::X 'DOUBLE-FLOAT)
; --> THE 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/multinomial.lisp
; in: DEFUN RANDOM-MULTINOMIAL%
;     (ARRAY-DIMENSION RANDOM-DISTRIBUTIONS::P 0)
; 
; note: unable to optimize because: The array dimensions are unknown; must call ARRAY-DIMENSION at runtime.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/multinomial.lisp
; in: DEFUN TEST-MULTINOMIAL1
;     (ARRAY-DIMENSION RANDOM-DISTRIBUTIONS::P 0)
; 
; note: unable to optimize because: The array dimensions are unknown; must call ARRAY-DIMENSION at runtime.

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

;     (* RANDOM-DISTRIBUTIONS::NN
;        (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

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

;     (* RANDOM-DISTRIBUTIONS::NN
;        (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J)
;        (- 1.0d0 (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J)))
; --> * 
; ==>
;   (* RANDOM-DISTRIBUTIONS::NN
;      (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

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

;     (* RANDOM-DISTRIBUTIONS::NN
;        (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J)
;        (- 1.0d0 (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J)))
; ==>
;   (*
;    (* RANDOM-DISTRIBUTIONS::NN
;       (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J))
;    (- 1.0d0 (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J)))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (LOOP RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::I RANDOM-DISTRIBUTIONS::FROM 0 RANDOM-DISTRIBUTIONS::TO RANDOM-DISTRIBUTIONS::K
;           DO (PROGN
;               (RANDOM-DISTRIBUTIONS::RANDOM-MULTINOMIAL1 RANDOM-DISTRIBUTIONS::NN
;                RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::N)
;               (LOOP RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::J RANDOM-DISTRIBUTIONS::FROM 0 RANDOM-DISTRIBUTIONS::TO (1-
;                                                                                                                              RANDOM-DISTRIBUTIONS::D)
;                     DO (PUSH
;                         (AREF RANDOM-DISTRIBUTIONS::N RANDOM-DISTRIBUTIONS::J)
;                         (AREF RANDOM-DISTRIBUTIONS::R RANDOM-DISTRIBUTIONS::J)))))
; --> BLOCK LET TAGBODY WHEN IF 
; ==>
;   (> RANDOM-DISTRIBUTIONS::I #:LOOP-LIMIT-0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

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

;     (FLOAT
;      (RANDOM-DISTRIBUTIONS::MEAN
;       (AREF RANDOM-DISTRIBUTIONS::R RANDOM-DISTRIBUTIONS::J)))
; --> IF 
; ==>
;   (SB-KERNEL:%SINGLE-FLOAT SB-C::N)
; 
; 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).

;     (* RANDOM-DISTRIBUTIONS::NN
;        (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::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 &REST T).
;       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 T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (FLOAT
;      (RANDOM-DISTRIBUTIONS::VAR
;       (AREF RANDOM-DISTRIBUTIONS::R RANDOM-DISTRIBUTIONS::J)))
; --> IF 
; ==>
;   (SB-KERNEL:%SINGLE-FLOAT SB-C::N)
; 
; 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).

;     (* RANDOM-DISTRIBUTIONS::NN
;        (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J)
;        (- 1.0d0 (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J)))
; --> * 
; ==>
;   (* RANDOM-DISTRIBUTIONS::NN
;      (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J))
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (- 1.0d0 (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J))
; 
; 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 NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       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 NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).

;     (* RANDOM-DISTRIBUTIONS::NN
;        (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J)
;        (- 1.0d0 (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J)))
; ==>
;   (*
;    (* RANDOM-DISTRIBUTIONS::NN
;       (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J))
;    (- 1.0d0 (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J)))
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/exponential.lisp
; in: DEFUN RANDOM-EXPONENTIAL
;     (DEFUN RANDOM-DISTRIBUTIONS:RANDOM-EXPONENTIAL (RANDOM-DISTRIBUTIONS::MU)
;       "Random values for:
;   p(x) dx = exp(-x/mu) dx/mu"
;       (DECLARE (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::MU))
;       (* (- RANDOM-DISTRIBUTIONS::MU)
;          (LOG (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RANDOM-DISTRIBUTIONS:RANDOM-EXPONENTIAL
;         (RANDOM-DISTRIBUTIONS::MU)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       "Random values for:
; p(x) dx = exp(-x/mu) dx/mu"
;       (DECLARE (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::MU))
;       (BLOCK RANDOM-DISTRIBUTIONS:RANDOM-EXPONENTIAL
;         (* (- RANDOM-DISTRIBUTIONS::MU)
;            (LOG (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM)))))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/f.lisp
; in: DEFUN RANDOM-F
;     (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA (/ RANDOM-DISTRIBUTIONS::NU1 2.0d0) 2.0d0)
; --> BLOCK 
; ==>
;   (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-MT RANDOM-DISTRIBUTIONS::A
;                                         RANDOM-DISTRIBUTIONS::B)
; 
; note: doing float to pointer coercion (cost 13)

;     (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA (/ RANDOM-DISTRIBUTIONS::NU2 2.0d0) 2.0d0)
; --> BLOCK 
; ==>
;   (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-MT RANDOM-DISTRIBUTIONS::A
;                                         RANDOM-DISTRIBUTIONS::B)
; 
; note: doing float to pointer coercion (cost 13)

;     (DEFUN RANDOM-DISTRIBUTIONS:RANDOM-F
;            (RANDOM-DISTRIBUTIONS::NU1 RANDOM-DISTRIBUTIONS::NU2)
;       "Random value for:
;   
;   p(x) dx = (nu1^(nu1/2) nu2^(nu2/2) Gamma((nu1 + nu2)/2) /
;   Gamma(nu1/2) Gamma(nu2/2)) *
;   x^(nu1/2 - 1) (nu2 + nu1 * x)^(-nu1/2 -nu2/2) dx"
;       (DECLARE
;        (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::NU1 RANDOM-DISTRIBUTIONS::NU2))
;       (LET ((RANDOM-DISTRIBUTIONS::Y1
;              (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA # 2.0d0))
;             (RANDOM-DISTRIBUTIONS::Y2
;              (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA # 2.0d0)))
;         (DECLARE
;          (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::Y1 RANDOM-DISTRIBUTIONS::Y2))
;         (/ (* RANDOM-DISTRIBUTIONS::Y1 RANDOM-DISTRIBUTIONS::NU2)
;            (* RANDOM-DISTRIBUTIONS::Y2 RANDOM-DISTRIBUTIONS::NU1))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RANDOM-DISTRIBUTIONS:RANDOM-F
;         (RANDOM-DISTRIBUTIONS::NU1 RANDOM-DISTRIBUTIONS::NU2)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       "Random value for:
; 
; p(x) dx = (nu1^(nu1/2) nu2^(nu2/2) Gamma((nu1 + nu2)/2) /
; Gamma(nu1/2) Gamma(nu2/2)) *
; x^(nu1/2 - 1) (nu2 + nu1 * x)^(-nu1/2 -nu2/2) dx"
;       (DECLARE
;        (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::NU1 RANDOM-DISTRIBUTIONS::NU2))
;       (BLOCK RANDOM-DISTRIBUTIONS:RANDOM-F
;         (LET ((RANDOM-DISTRIBUTIONS::Y1 #) (RANDOM-DISTRIBUTIONS::Y2 #))
;           (DECLARE
;            (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::Y1
;             RANDOM-DISTRIBUTIONS::Y2))
;           (/ (* RANDOM-DISTRIBUTIONS::Y1 RANDOM-DISTRIBUTIONS::NU2)
;              (* RANDOM-DISTRIBUTIONS::Y2 RANDOM-DISTRIBUTIONS::NU1)))))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/pareto.lisp
; in: DEFUN RANDOM-PARETO
;     (DEFUN RANDOM-DISTRIBUTIONS:RANDOM-PARETO
;            (RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B)
;       "Random value for parato distribution:
;   p(x) dx = (a/b) / (x/b)^(a+1) dx     for x >= b"
;       (DECLARE
;        (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B))
;       (LET* ((RANDOM-DISTRIBUTIONS::X (RANDOM-DISTRIBUTIONS::RANDOM-POS))
;              (RANDOM-DISTRIBUTIONS::Z (EXPT RANDOM-DISTRIBUTIONS::X #)))
;         (* RANDOM-DISTRIBUTIONS::B RANDOM-DISTRIBUTIONS::Z)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RANDOM-DISTRIBUTIONS:RANDOM-PARETO
;         (RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       "Random value for parato distribution:
; p(x) dx = (a/b) / (x/b)^(a+1) dx     for x >= b"
;       (DECLARE
;        (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B))
;       (BLOCK RANDOM-DISTRIBUTIONS:RANDOM-PARETO
;         (LET* ((RANDOM-DISTRIBUTIONS::X #) (RANDOM-DISTRIBUTIONS::Z #))
;           (* RANDOM-DISTRIBUTIONS::B RANDOM-DISTRIBUTIONS::Z))))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/chisq.lisp
; in: DEFUN RANDOM-CHI-SQUARE
;     (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA (/ RANDOM-DISTRIBUTIONS::NU 2.0d0))
; --> BLOCK 
; ==>
;   (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-MT RANDOM-DISTRIBUTIONS::A
;                                         RANDOM-DISTRIBUTIONS::B)
; 
; note: doing float to pointer coercion (cost 13)

;     (DEFUN RANDOM-DISTRIBUTIONS:RANDOM-CHI-SQUARE (RANDOM-DISTRIBUTIONS::NU)
;       "Generate random variable for chi square distribution:
;   
;   p(x) dx = (1/(2*Gamma(nu/2))) (x/2)^(nu/2 - 1) exp(-x/2) dx"
;       (DECLARE (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::NU))
;       (* 2.0d0
;          (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA (/ RANDOM-DISTRIBUTIONS::NU 2.0d0))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RANDOM-DISTRIBUTIONS:RANDOM-CHI-SQUARE
;         (RANDOM-DISTRIBUTIONS::NU)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       "Generate random variable for chi square distribution:
; 
; p(x) dx = (1/(2*Gamma(nu/2))) (x/2)^(nu/2 - 1) exp(-x/2) dx"
;       (DECLARE (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::NU))
;       (BLOCK RANDOM-DISTRIBUTIONS:RANDOM-CHI-SQUARE
;         (* 2.0d0
;            (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA
;             (/ RANDOM-DISTRIBUTIONS::NU 2.0d0)))))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/t.lisp
; in: DEFUN RANDOM-T
;     (DEFUN RANDOM-DISTRIBUTIONS::RANDOM-T (RANDOM-DISTRIBUTIONS::NU)
;       (DECLARE (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::NU))
;       (IF (<= RANDOM-DISTRIBUTIONS::NU 2.0d0)
;           (RANDOM-DISTRIBUTIONS::RANDOM-T-NU<=2 RANDOM-DISTRIBUTIONS::NU)
;           (RANDOM-DISTRIBUTIONS::RANDOM-T-NU>2 RANDOM-DISTRIBUTIONS::NU)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RANDOM-DISTRIBUTIONS::RANDOM-T
;         (RANDOM-DISTRIBUTIONS::NU)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::NU))
;       (BLOCK RANDOM-DISTRIBUTIONS::RANDOM-T
;         (IF (<= RANDOM-DISTRIBUTIONS::NU 2.0d0)
;             (RANDOM-DISTRIBUTIONS::RANDOM-T-NU<=2 RANDOM-DISTRIBUTIONS::NU)
;             (RANDOM-DISTRIBUTIONS::RANDOM-T-NU>2 RANDOM-DISTRIBUTIONS::NU))))
; 
; note: type assertion too complex to check:
; (VALUES DOUBLE-FLOAT &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/desc-stat.lisp
; in: DEFMACRO VAR
;     (DEFMACRO RANDOM-DISTRIBUTIONS::VAR (&REST RANDOM-DISTRIBUTIONS::ARGS)
;       `(RANDOM-DISTRIBUTIONS::VARIANCE ,@RANDOM-DISTRIBUTIONS::ARGS))
; --> PROGN EVAL-WHEN 
; ==>
;   (SB-C::%DEFMACRO 'RANDOM-DISTRIBUTIONS::VAR
;                    (SB-INT:NAMED-LAMBDA (MACRO-FUNCTION
;                                          RANDOM-DISTRIBUTIONS::VAR)
;                        (#:EXPR #:ENV)
;                      (DECLARE
;                       (SB-C::LAMBDA-LIST (&REST RANDOM-DISTRIBUTIONS::ARGS)))
;                      (DECLARE (IGNORE #:ENV))
;                      (SB-INT:NAMED-DS-BIND (:MACRO RANDOM-DISTRIBUTIONS::VAR
;                                             . DEFMACRO)
;                          (&REST RANDOM-DISTRIBUTIONS::ARGS)
;                          (CDR #:EXPR)
;                        (BLOCK RANDOM-DISTRIBUTIONS::VAR
;                          `(RANDOM-DISTRIBUTIONS::VARIANCE
;                            ,@RANDOM-DISTRIBUTIONS::ARGS))))
;                    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   VAR is being redefined as a macro when it was previously assumed to be a function.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "cl-randist" "desc-stat">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/GIG.lisp
; in: DEFUN TRANSFER-SIGN
;     (ABS RANDOM-DISTRIBUTIONS::A)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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 (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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 (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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.

;     (- (ABS RANDOM-DISTRIBUTIONS::A))
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (ABS RANDOM-DISTRIBUTIONS::A)))
; 
; note: unable to Eliminate %negate/%negate of rationals due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a RATIONAL.

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

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

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

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

;     (- (ABS RANDOM-DISTRIBUTIONS::A))
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (ABS RANDOM-DISTRIBUTIONS::A)))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (RATIONAL * 0) (SINGLE-FLOAT * -0.0) (DOUBLE-FLOAT * -0.0d0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR (RATIONAL * 0) (SINGLE-FLOAT * -0.0) (DOUBLE-FLOAT * -0.0d0)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/GIG.lisp
; in: DEFUN ZEROIN
;     (FUNCALL RANDOM-DISTRIBUTIONS::FUN RANDOM-DISTRIBUTIONS::A)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL RANDOM-DISTRIBUTIONS::FUN)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: FUN is not known to be a function

;     (FUNCALL RANDOM-DISTRIBUTIONS::FUN RANDOM-DISTRIBUTIONS::B)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL RANDOM-DISTRIBUTIONS::FUN)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: FUN is not known to be a function

;     (ABS RANDOM-DISTRIBUTIONS::FC)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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 (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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.

;     (ABS RANDOM-DISTRIBUTIONS::FB)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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 (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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.

;     (ABS RANDOM-DISTRIBUTIONS::B)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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 (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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.

;     (ABS RANDOM-DISTRIBUTIONS::XM)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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 (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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.

;     (= RANDOM-DISTRIBUTIONS::FB 0.0d0)
; 
; 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.

;     (ABS RANDOM-DISTRIBUTIONS::E)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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 (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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.

;     (< (ABS RANDOM-DISTRIBUTIONS::E) RANDOM-DISTRIBUTIONS::TOL1)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a FLOAT.The second argument is a REAL, not a RATIONAL.

;     (ABS RANDOM-DISTRIBUTIONS::FA)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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 (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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.

;     (ABS RANDOM-DISTRIBUTIONS::FB)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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 (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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.

;     (= RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::C)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a FLOAT.The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)).The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

;     (/ RANDOM-DISTRIBUTIONS::FB RANDOM-DISTRIBUTIONS::FA)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (* 2.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::S)
; --> * 
; ==>
;   (* 2.0d0 RANDOM-DISTRIBUTIONS::XM)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.

; ==>
;   (* (* 2.0d0 RANDOM-DISTRIBUTIONS::XM) RANDOM-DISTRIBUTIONS::S)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (/ RANDOM-DISTRIBUTIONS::FA RANDOM-DISTRIBUTIONS::FC)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (/ RANDOM-DISTRIBUTIONS::FB RANDOM-DISTRIBUTIONS::FC)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (/ RANDOM-DISTRIBUTIONS::FB RANDOM-DISTRIBUTIONS::FA)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (* 2.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;        (- RANDOM-DISTRIBUTIONS::Q RANDOM-DISTRIBUTIONS::R))
; --> * * 
; ==>
;   (* 2.0d0 RANDOM-DISTRIBUTIONS::XM)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.

; --> * 
; ==>
;   (* (* 2.0d0 RANDOM-DISTRIBUTIONS::XM) RANDOM-DISTRIBUTIONS::Q)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

; ==>
;   (* (* (* 2.0d0 RANDOM-DISTRIBUTIONS::XM) RANDOM-DISTRIBUTIONS::Q)
;      (- RANDOM-DISTRIBUTIONS::Q RANDOM-DISTRIBUTIONS::R))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (* (- RANDOM-DISTRIBUTIONS::B RANDOM-DISTRIBUTIONS::A)
;        (- RANDOM-DISTRIBUTIONS::R 1.0d0))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (* RANDOM-DISTRIBUTIONS::S
;        (-
;         (* 2.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;            (- RANDOM-DISTRIBUTIONS::Q RANDOM-DISTRIBUTIONS::R))
;         (* (- RANDOM-DISTRIBUTIONS::B RANDOM-DISTRIBUTIONS::A)
;            (- RANDOM-DISTRIBUTIONS::R 1.0d0))))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (* (- RANDOM-DISTRIBUTIONS::Q 1.0d0) (- RANDOM-DISTRIBUTIONS::R 1.0d0)
;        (- RANDOM-DISTRIBUTIONS::S 1.0d0))
; --> * 
; ==>
;   (* (- RANDOM-DISTRIBUTIONS::Q 1.0d0) (- RANDOM-DISTRIBUTIONS::R 1.0d0))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

; ==>
;   (* (* (- RANDOM-DISTRIBUTIONS::Q 1.0d0) (- RANDOM-DISTRIBUTIONS::R 1.0d0))
;      (- RANDOM-DISTRIBUTIONS::S 1.0d0))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

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

;     (ABS RANDOM-DISTRIBUTIONS::P)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (* 2.0d0 RANDOM-DISTRIBUTIONS::P)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.

;     (* 3.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;        (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q)))
; --> * 
; ==>
;   (* (* 3.0d0 RANDOM-DISTRIBUTIONS::XM) RANDOM-DISTRIBUTIONS::Q)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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 (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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.

;     (* 3.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;        (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q)))
; ==>
;   (* (* (* 3.0d0 RANDOM-DISTRIBUTIONS::XM) RANDOM-DISTRIBUTIONS::Q)
;      (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q)))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a INTEGER.

;     (-
;      (* 3.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;         (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q))))
; ==>
;   (SB-KERNEL:%NEGATE
;    (THE NUMBER
;         (* 3.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;            (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q)))))
; 
; note: unable to Eliminate %negate/%negate of rationals due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (* 0.5d0 RANDOM-DISTRIBUTIONS::E RANDOM-DISTRIBUTIONS::Q)
; ==>
;   (* (* 0.5d0 RANDOM-DISTRIBUTIONS::E) RANDOM-DISTRIBUTIONS::Q)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (ABS (* 0.5d0 RANDOM-DISTRIBUTIONS::E RANDOM-DISTRIBUTIONS::Q))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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 (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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.

;     (ABS RANDOM-DISTRIBUTIONS::D)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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 (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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.

;     (> (ABS RANDOM-DISTRIBUTIONS::D) RANDOM-DISTRIBUTIONS::TOL1)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a FLOAT.The second argument is a REAL, not a RATIONAL.

;     (FUNCALL RANDOM-DISTRIBUTIONS::FUN RANDOM-DISTRIBUTIONS::B)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL RANDOM-DISTRIBUTIONS::FUN)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: FUN is not known to be a function

;     (ABS RANDOM-DISTRIBUTIONS::FC)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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 (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 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.

;     (/ RANDOM-DISTRIBUTIONS::FC (ABS RANDOM-DISTRIBUTIONS::FC))
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a INTEGER.

;     (* RANDOM-DISTRIBUTIONS::FB
;        (/ RANDOM-DISTRIBUTIONS::FC (ABS RANDOM-DISTRIBUTIONS::FC)))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (>
;      (* RANDOM-DISTRIBUTIONS::FB
;         (/ RANDOM-DISTRIBUTIONS::FC (ABS RANDOM-DISTRIBUTIONS::FC)))
;      0.0d0)
; 
; note: unable to open-code RATIONAL to FLOAT comparison due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (RANDOM-DISTRIBUTIONS::TRANSFER-SIGN RANDOM-DISTRIBUTIONS::TOL1
;      RANDOM-DISTRIBUTIONS::XM)
; --> BLOCK IF 
; ==>
;   (ABS RANDOM-DISTRIBUTIONS::A)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a RATIONAL.

; --> BLOCK IF - SB-KERNEL:%NEGATE THE 
; ==>
;   (ABS RANDOM-DISTRIBUTIONS::A)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a RATIONAL.

; --> BLOCK IF - 
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (ABS RANDOM-DISTRIBUTIONS::A)))
; 
; note: unable to Eliminate %negate/%negate of rationals due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a RATIONAL.

;     (>= (ABS RANDOM-DISTRIBUTIONS::FC) (ABS RANDOM-DISTRIBUTIONS::FB))
; --> OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a FLOAT.The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a RATIONAL.

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

;     (<= (ABS RANDOM-DISTRIBUTIONS::XM) RANDOM-DISTRIBUTIONS::TOL1)
; --> OR LET < IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a FLOAT.The second argument is a REAL, not a RATIONAL.

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

;     (<= (ABS RANDOM-DISTRIBUTIONS::FA) (ABS RANDOM-DISTRIBUTIONS::FB))
; --> OR LET < IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a FLOAT.The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a RATIONAL.

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

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

; --> OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; 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 REAL, not a RATIONAL.

;     (>= (* 2.0d0 RANDOM-DISTRIBUTIONS::P)
;         (-
;          (* 3.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;             (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q)))))
; --> OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The second argument is a REAL, not a RATIONAL.

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

;     (>= RANDOM-DISTRIBUTIONS::P
;         (ABS (* 0.5d0 RANDOM-DISTRIBUTIONS::E RANDOM-DISTRIBUTIONS::Q)))
; --> OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a FLOAT.The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a RATIONAL.

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

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

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

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

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

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

;     (>= (ABS RANDOM-DISTRIBUTIONS::FC) (ABS RANDOM-DISTRIBUTIONS::FB))
; --> OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a SINGLE-FLOAT.
;       The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.
;       The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.
;       etc.

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

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

;     (* 2.0 RANDOM-DISTRIBUTIONS::EPS (ABS RANDOM-DISTRIBUTIONS::B))
; ==>
;   (* (* 2.0 RANDOM-DISTRIBUTIONS::EPS) (ABS RANDOM-DISTRIBUTIONS::B))
; 
; 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) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.

;     (* 0.5 RANDOM-DISTRIBUTIONS::TOL)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).

;     (+ (* 2.0 RANDOM-DISTRIBUTIONS::EPS (ABS RANDOM-DISTRIBUTIONS::B))
;        (* 0.5 RANDOM-DISTRIBUTIONS::TOL))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).

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

;     (* 0.5 (- RANDOM-DISTRIBUTIONS::C RANDOM-DISTRIBUTIONS::B))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).

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

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

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

;     (= RANDOM-DISTRIBUTIONS::FB 0.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.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

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

;     (< (ABS RANDOM-DISTRIBUTIONS::E) RANDOM-DISTRIBUTIONS::TOL1)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

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

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

;     (<= (ABS RANDOM-DISTRIBUTIONS::FA) (ABS RANDOM-DISTRIBUTIONS::FB))
; --> OR LET < IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a SINGLE-FLOAT.
;       The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.
;       The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.
;       etc.

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

;     (= RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::C)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       etc.

;     (/ RANDOM-DISTRIBUTIONS::FB RANDOM-DISTRIBUTIONS::FA)
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (* 2.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::S)
; --> * 
; ==>
;   (* 2.0d0 RANDOM-DISTRIBUTIONS::XM)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

; ==>
;   (* (* 2.0d0 RANDOM-DISTRIBUTIONS::XM) RANDOM-DISTRIBUTIONS::S)
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (- 1.0d0 RANDOM-DISTRIBUTIONS::S)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).

;     (/ RANDOM-DISTRIBUTIONS::FA RANDOM-DISTRIBUTIONS::FC)
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (/ RANDOM-DISTRIBUTIONS::FB RANDOM-DISTRIBUTIONS::FC)
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (/ RANDOM-DISTRIBUTIONS::FB RANDOM-DISTRIBUTIONS::FA)
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (* 2.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;        (- RANDOM-DISTRIBUTIONS::Q RANDOM-DISTRIBUTIONS::R))
; --> * * 
; ==>
;   (* 2.0d0 RANDOM-DISTRIBUTIONS::XM)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

; --> * 
; ==>
;   (* (* 2.0d0 RANDOM-DISTRIBUTIONS::XM) RANDOM-DISTRIBUTIONS::Q)
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

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

;     (* 2.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;        (- RANDOM-DISTRIBUTIONS::Q RANDOM-DISTRIBUTIONS::R))
; ==>
;   (* (* (* 2.0d0 RANDOM-DISTRIBUTIONS::XM) RANDOM-DISTRIBUTIONS::Q)
;      (- RANDOM-DISTRIBUTIONS::Q RANDOM-DISTRIBUTIONS::R))
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

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

;     (- RANDOM-DISTRIBUTIONS::R 1.0d0)
; 
; 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 result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).

;     (* (- RANDOM-DISTRIBUTIONS::B RANDOM-DISTRIBUTIONS::A)
;        (- RANDOM-DISTRIBUTIONS::R 1.0d0))
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (-
;      (* 2.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;         (- RANDOM-DISTRIBUTIONS::Q RANDOM-DISTRIBUTIONS::R))
;      (* (- RANDOM-DISTRIBUTIONS::B RANDOM-DISTRIBUTIONS::A)
;         (- RANDOM-DISTRIBUTIONS::R 1.0d0)))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (* RANDOM-DISTRIBUTIONS::S
;        (-
;         (* 2.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;            (- RANDOM-DISTRIBUTIONS::Q RANDOM-DISTRIBUTIONS::R))
;         (* (- RANDOM-DISTRIBUTIONS::B RANDOM-DISTRIBUTIONS::A)
;            (- RANDOM-DISTRIBUTIONS::R 1.0d0))))
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::Q 1.0d0)
; 
; 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 result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).

;     (- RANDOM-DISTRIBUTIONS::R 1.0d0)
; 
; 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 result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).

;     (* (- RANDOM-DISTRIBUTIONS::Q 1.0d0) (- RANDOM-DISTRIBUTIONS::R 1.0d0)
;        (- RANDOM-DISTRIBUTIONS::S 1.0d0))
; --> * 
; ==>
;   (* (- RANDOM-DISTRIBUTIONS::Q 1.0d0) (- RANDOM-DISTRIBUTIONS::R 1.0d0))
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::S 1.0d0)
; 
; 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 result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).

;     (* (- RANDOM-DISTRIBUTIONS::Q 1.0d0) (- RANDOM-DISTRIBUTIONS::R 1.0d0)
;        (- RANDOM-DISTRIBUTIONS::S 1.0d0))
; ==>
;   (* (* (- RANDOM-DISTRIBUTIONS::Q 1.0d0) (- RANDOM-DISTRIBUTIONS::R 1.0d0))
;      (- RANDOM-DISTRIBUTIONS::S 1.0d0))
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

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

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

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

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

;     (* 2.0d0 RANDOM-DISTRIBUTIONS::P)
; 
; 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) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.

;     (* 3.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;        (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q)))
; --> * * 
; ==>
;   (* 3.0d0 RANDOM-DISTRIBUTIONS::XM)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

; --> * 
; ==>
;   (* (* 3.0d0 RANDOM-DISTRIBUTIONS::XM) RANDOM-DISTRIBUTIONS::Q)
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q)
; 
; 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 NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).

;     (* 3.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;        (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q)))
; ==>
;   (* (* (* 3.0d0 RANDOM-DISTRIBUTIONS::XM) RANDOM-DISTRIBUTIONS::Q)
;      (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q)))
; 
; 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 (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       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 (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (-
;      (* 3.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;         (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q))))
; ==>
;   (SB-KERNEL:%NEGATE
;    (THE NUMBER
;         (* 3.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;            (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q)))))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       etc.

;     (>= (* 2.0d0 RANDOM-DISTRIBUTIONS::P)
;         (-
;          (* 3.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;             (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q)))))
; --> OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The second argument is a REAL, not a DOUBLE-FLOAT.

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

;     (* 0.5d0 RANDOM-DISTRIBUTIONS::E RANDOM-DISTRIBUTIONS::Q)
; --> * 
; ==>
;   (* 0.5d0 RANDOM-DISTRIBUTIONS::E)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

; ==>
;   (* (* 0.5d0 RANDOM-DISTRIBUTIONS::E) RANDOM-DISTRIBUTIONS::Q)
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (ABS (* 0.5d0 RANDOM-DISTRIBUTIONS::E RANDOM-DISTRIBUTIONS::Q))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).

;     (>= RANDOM-DISTRIBUTIONS::P
;         (ABS (* 0.5d0 RANDOM-DISTRIBUTIONS::E RANDOM-DISTRIBUTIONS::Q)))
; --> OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a SINGLE-FLOAT.
;       The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.
;       The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.
;       etc.

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

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

;     (> (ABS RANDOM-DISTRIBUTIONS::D) RANDOM-DISTRIBUTIONS::TOL1)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

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

;     (RANDOM-DISTRIBUTIONS::TRANSFER-SIGN RANDOM-DISTRIBUTIONS::TOL1
;      RANDOM-DISTRIBUTIONS::XM)
; --> BLOCK IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; --> BLOCK IF - SB-KERNEL:%NEGATE THE 
; ==>
;   (ABS RANDOM-DISTRIBUTIONS::A)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).

; --> BLOCK IF - 
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (ABS RANDOM-DISTRIBUTIONS::A)))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (RATIONAL * 0) (SINGLE-FLOAT * -0.0) (DOUBLE-FLOAT * -0.0d0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR (RATIONAL * 0) (SINGLE-FLOAT * -0.0) (DOUBLE-FLOAT * -0.0d0)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> BLOCK IF 
; ==>
;   (ABS RANDOM-DISTRIBUTIONS::A)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).

;     (+ RANDOM-DISTRIBUTIONS::B
;        (RANDOM-DISTRIBUTIONS::TRANSFER-SIGN RANDOM-DISTRIBUTIONS::TOL1
;         RANDOM-DISTRIBUTIONS::XM))
; 
; 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 REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

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

;     (/ RANDOM-DISTRIBUTIONS::FC (ABS RANDOM-DISTRIBUTIONS::FC))
; 
; 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 (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (* RANDOM-DISTRIBUTIONS::FB
;        (/ RANDOM-DISTRIBUTIONS::FC (ABS RANDOM-DISTRIBUTIONS::FC)))
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (>
;      (* RANDOM-DISTRIBUTIONS::FB
;         (/ RANDOM-DISTRIBUTIONS::FC (ABS RANDOM-DISTRIBUTIONS::FC)))
;      0.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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/GIG.lisp
; in: DEFUN GIG-SETUP
;     (SQRT (/ RANDOM-DISTRIBUTIONS::PSI RANDOM-DISTRIBUTIONS::CHI))
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (SQRT (* RANDOM-DISTRIBUTIONS::PSI RANDOM-DISTRIBUTIONS::CHI))
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (SQRT
;      (+ (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::L1)
;         (* RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::BETA)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (/
;      (+ RANDOM-DISTRIBUTIONS::L1
;         (SQRT
;          (+ (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::L1)
;             (* RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::BETA))))
;      RANDOM-DISTRIBUTIONS::BETA)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a (COMPLEX DOUBLE-FLOAT).The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a DOUBLE-FLOAT.The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), not a (COMPLEX DOUBLE-FLOAT).

;     (> (RANDOM-DISTRIBUTIONS::G RANDOM-DISTRIBUTIONS::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.

;     (/ RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
; 
; note: unable to optimize due to type uncertainty: 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).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).

;     (EXPT (/ RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;           (* 0.5d0 RANDOM-DISTRIBUTIONS::L1))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (DOUBLE-FLOAT 0.0d0).

;     (* (- RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;        (EXPT (/ RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;              (* 0.5d0 RANDOM-DISTRIBUTIONS::L1))
;        (EXP
;         (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;            (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP)
;               (- RANDOM-DISTRIBUTIONS::M) (- #)))))
; --> * 
; ==>
;   (* (- RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;      (EXPT (/ RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;            (* 0.5d0 RANDOM-DISTRIBUTIONS::L1)))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (/ RANDOM-DISTRIBUTIONS::YP)
; ==>
;   (/ 1 (THE NUMBER RANDOM-DISTRIBUTIONS::YP))
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The second argument is a NUMBER, not a INTEGER.

;     (EXP
;      (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;         (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP)
;            (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M)))))
; 
; 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.

;     (/ RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
; 
; note: unable to optimize due to type uncertainty: 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).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).

;     (EXPT (/ RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;           (* 0.5d0 RANDOM-DISTRIBUTIONS::L1))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (DOUBLE-FLOAT 0.0d0).

;     (* (- RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;        (EXPT (/ RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;              (* 0.5d0 RANDOM-DISTRIBUTIONS::L1))
;        (EXP
;         (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;            (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM)
;               (- RANDOM-DISTRIBUTIONS::M) (- #)))))
; --> * 
; ==>
;   (* (- RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;      (EXPT (/ RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;            (* 0.5d0 RANDOM-DISTRIBUTIONS::L1)))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (/ RANDOM-DISTRIBUTIONS::YM)
; ==>
;   (/ 1 (THE NUMBER RANDOM-DISTRIBUTIONS::YM))
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The second argument is a NUMBER, not a INTEGER.

;     (EXP
;      (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;         (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM)
;            (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M)))))
; 
; 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.

;     (LOG RANDOM-DISTRIBUTIONS::M)
; 
; note: unable to optimize due to type uncertainty: 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 FLOAT &REST T).

;     (* 2 RANDOM-DISTRIBUTIONS::X)
; 
; 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.
; 
; note: unable to associate */(* /) of constants due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (EXPT RANDOM-DISTRIBUTIONS::Y 3)
; --> * * 
; ==>
;   (* SB-C::X SB-C::X)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

; --> * 
; ==>
;   (* (* SB-C::X SB-C::X) SB-C::X)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y
;        (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA
;           1.0d0))
; --> * 
; ==>
;   (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (-
;      (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y
;         (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA
;            1.0d0)))
; ==>
;   (SB-KERNEL:%NEGATE
;    (THE NUMBER
;         (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y
;            (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M)
;               LAMBDA 1.0d0))))
; 
; note: unable to Eliminate %negate/%negate of rationals due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA (EXPT RANDOM-DISTRIBUTIONS::Y 3))
; --> * 
; ==>
;   (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), 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) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT -0.0d0) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (EXPT RANDOM-DISTRIBUTIONS::Y 3)
; --> * * 
; ==>
;   (* SB-C::X SB-C::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 &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

; --> * 
; ==>
;   (* (* SB-C::X SB-C::X) SB-C::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 &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA (EXPT RANDOM-DISTRIBUTIONS::Y 3))
; ==>
;   (* (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA) (EXPT RANDOM-DISTRIBUTIONS::Y 3))
; 
; 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 (COMPLEX DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       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 second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       etc.

;     (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y
;        (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA
;           1.0d0))
; --> * 
; ==>
;   (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y)
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M)
; --> * 
; ==>
;   (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), 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) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT -0.0d0) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

; ==>
;   (* (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA) RANDOM-DISTRIBUTIONS::M)
; 
; 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 (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       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 second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       etc.

;     (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA 1.0d0)
; --> + 
; ==>
;   (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) 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) &REST T).

; ==>
;   (+ (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA)
;      1.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 result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       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 (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).

;     (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y
;        (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA
;           1.0d0))
; ==>
;   (* (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y)
;      (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA
;         1.0d0))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       etc.

;     (-
;      (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y
;         (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA
;            1.0d0)))
; ==>
;   (SB-KERNEL:%NEGATE
;    (THE NUMBER
;         (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y
;            (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M)
;               LAMBDA 1.0d0))))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       etc.

;     (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA (EXPT RANDOM-DISTRIBUTIONS::Y 3))
;        (-
;         (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y
;            (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA
;               1.0d0)))
;        (* RANDOM-DISTRIBUTIONS::Y
;           (- (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::M)
;              (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA)))
;        (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M))
; --> + + 
; ==>
;   (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA (EXPT RANDOM-DISTRIBUTIONS::Y 3))
;      (-
;       (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y
;          (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA
;             1.0d0))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::M)
; 
; 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 DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       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 (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).

;     (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), 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) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT -0.0d0) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (- (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::M)
;        (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) 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 &REST T).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) 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) &REST T).
;       etc.

;     (* RANDOM-DISTRIBUTIONS::Y
;        (- (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::M)
;           (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) 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 DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) 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 NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       etc.

;     (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA (EXPT RANDOM-DISTRIBUTIONS::Y 3))
;        (-
;         (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y
;            (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA
;               1.0d0)))
;        (* RANDOM-DISTRIBUTIONS::Y
;           (- (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::M)
;              (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA)))
;        (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M))
; --> + 
; ==>
;   (+
;    (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA (EXPT RANDOM-DISTRIBUTIONS::Y 3))
;       (-
;        (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y (+ # LAMBDA 1.0d0))))
;    (* RANDOM-DISTRIBUTIONS::Y
;       (- (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::M)
;          (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M)
; --> * 
; ==>
;   (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), 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) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT -0.0d0) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

; ==>
;   (* (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA) RANDOM-DISTRIBUTIONS::M)
; 
; 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 (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       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 second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       etc.

;     (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA (EXPT RANDOM-DISTRIBUTIONS::Y 3))
;        (-
;         (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y
;            (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA
;               1.0d0)))
;        (* RANDOM-DISTRIBUTIONS::Y
;           (- (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::M)
;              (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA)))
;        (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M))
; ==>
;   (+
;    (+
;     (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA (EXPT RANDOM-DISTRIBUTIONS::Y 3))
;        (- (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y #)))
;     (* RANDOM-DISTRIBUTIONS::Y
;        (- (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::M)
;           (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA))))
;    (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M))
; 
; 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 (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       etc.

;     (* RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::BETA)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), not a DOUBLE-FLOAT.
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       etc.

;     (+ (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::L1)
;        (* RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::BETA))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).

;     (+ RANDOM-DISTRIBUTIONS::L1
;        (SQRT
;         (+ (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::L1)
;            (* RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::BETA))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The second argument is a (OR (DOUBLE-FLOAT 0.0d0) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).

;     (/
;      (+ RANDOM-DISTRIBUTIONS::L1
;         (SQRT
;          (+ (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::L1)
;             (* RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::BETA))))
;      RANDOM-DISTRIBUTIONS::BETA)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a DOUBLE-FLOAT.
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (> (RANDOM-DISTRIBUTIONS::G RANDOM-DISTRIBUTIONS::X) 0.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.

;     (- RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
; 
; 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 NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       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 NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       etc.

;     (/ RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) 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 DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 19) 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 NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (* (- RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;        (EXPT (/ RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;              (* 0.5d0 RANDOM-DISTRIBUTIONS::L1))
;        (EXP
;         (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;            (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP)
;               (- RANDOM-DISTRIBUTIONS::M) (- #)))))
; --> * 
; ==>
;   (* (- RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;      (EXPT (/ RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;            (* 0.5d0 RANDOM-DISTRIBUTIONS::L1)))
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;        (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP)
;           (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M))))
; --> * 
; ==>
;   (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), 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) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT * 0.0d0) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

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

;     (- RANDOM-DISTRIBUTIONS::M)
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER RANDOM-DISTRIBUTIONS::M))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP)
;        (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M)))
; --> + 
; ==>
;   (+ (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP))
;      (- RANDOM-DISTRIBUTIONS::M))
; 
; 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 (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       etc.

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

;     (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP)
;        (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M)))
; ==>
;   (+
;    (+ (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP))
;       (- RANDOM-DISTRIBUTIONS::M))
;    (- (/ RANDOM-DISTRIBUTIONS::M)))
; 
; 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 NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       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 NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       etc.

;     (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;        (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP)
;           (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M))))
; ==>
;   (* (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA)
;      (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP)
;         (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M))))
; 
; 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 (COMPLEX DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       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 second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       etc.

;     (* (- RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;        (EXPT (/ RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;              (* 0.5d0 RANDOM-DISTRIBUTIONS::L1))
;        (EXP
;         (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;            (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP)
;               (- RANDOM-DISTRIBUTIONS::M) (- #)))))
; ==>
;   (*
;    (* (- RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;       (EXPT (/ RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;             (* 0.5d0 RANDOM-DISTRIBUTIONS::L1)))
;    (EXP
;     (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;        (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP)
;           (- RANDOM-DISTRIBUTIONS::M) (- #)))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a (OR (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0) (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a (OR (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0) (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
; 
; 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 NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       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 NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       etc.

;     (/ RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) 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 DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 19) 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 NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (* (- RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;        (EXPT (/ RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;              (* 0.5d0 RANDOM-DISTRIBUTIONS::L1))
;        (EXP
;         (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;            (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM)
;               (- RANDOM-DISTRIBUTIONS::M) (- #)))))
; --> * 
; ==>
;   (* (- RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;      (EXPT (/ RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;            (* 0.5d0 RANDOM-DISTRIBUTIONS::L1)))
; 
; 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 &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;        (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM)
;           (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M))))
; --> * 
; ==>
;   (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), 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) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT -0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT * 0.0d0) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

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

;     (- RANDOM-DISTRIBUTIONS::M)
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER RANDOM-DISTRIBUTIONS::M))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM)
;        (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M)))
; --> + 
; ==>
;   (+ (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM))
;      (- RANDOM-DISTRIBUTIONS::M))
; 
; 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 (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       etc.

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

;     (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM)
;        (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M)))
; ==>
;   (+
;    (+ (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM))
;       (- RANDOM-DISTRIBUTIONS::M))
;    (- (/ RANDOM-DISTRIBUTIONS::M)))
; 
; 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 NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       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 NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       etc.

;     (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;        (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM)
;           (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M))))
; ==>
;   (* (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA)
;      (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM)
;         (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M))))
; 
; 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 (COMPLEX DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       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 second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       etc.

;     (* (- RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;        (EXPT (/ RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;              (* 0.5d0 RANDOM-DISTRIBUTIONS::L1))
;        (EXP
;         (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;            (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM)
;               (- RANDOM-DISTRIBUTIONS::M) (- #)))))
; ==>
;   (*
;    (* (- RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;       (EXPT (/ RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;             (* 0.5d0 RANDOM-DISTRIBUTIONS::L1)))
;    (EXP
;     (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;        (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM)
;           (- RANDOM-DISTRIBUTIONS::M) (- #)))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a (OR (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0) (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a (OR (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0) (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (+ RANDOM-DISTRIBUTIONS::M (/ RANDOM-DISTRIBUTIONS::M))
; 
; 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 (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       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 (COMPLEX DOUBLE-FLOAT) 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) &REST T).
;       etc.

;     (* -0.25 RANDOM-DISTRIBUTIONS::BETA
;        (+ RANDOM-DISTRIBUTIONS::M (/ RANDOM-DISTRIBUTIONS::M)))
; ==>
;   (* (* -0.25 RANDOM-DISTRIBUTIONS::BETA)
;      (+ RANDOM-DISTRIBUTIONS::M (/ RANDOM-DISTRIBUTIONS::M)))
; 
; 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 (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       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 second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       etc.

;     (* 0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::M))
; ==>
;   (* (* 0.5d0 RANDOM-DISTRIBUTIONS::L1) (LOG RANDOM-DISTRIBUTIONS::M))
; 
; 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 DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       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 (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).

;     (+
;      (* -0.25 RANDOM-DISTRIBUTIONS::BETA
;         (+ RANDOM-DISTRIBUTIONS::M (/ RANDOM-DISTRIBUTIONS::M)))
;      (* 0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::M)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a DOUBLE-FLOAT.
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) 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) &REST T).
;       etc.

;     (* 2 RANDOM-DISTRIBUTIONS::X)
; 
; 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 &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (SQRT (/ RANDOM-DISTRIBUTIONS::PSI RANDOM-DISTRIBUTIONS::CHI))
; 
; note: doing float to pointer coercion (cost 13)

;     (SQRT (* RANDOM-DISTRIBUTIONS::PSI RANDOM-DISTRIBUTIONS::CHI))
; 
; note: doing float to pointer coercion (cost 13)

;     (- LAMBDA 1.0d0)
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first result of inline float arithmetic

;     (+ (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::L1)
;        (* RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::BETA))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first argument of GENERIC-+

;     (EXPT (/ RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;           (* 0.5d0 RANDOM-DISTRIBUTIONS::L1))
; 
; note: doing float to pointer coercion (cost 13)

;     (EXPT (/ RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;           (* 0.5d0 RANDOM-DISTRIBUTIONS::L1))
; 
; note: doing float to pointer coercion (cost 13)

;     (* 0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::M))
; ==>
;   (* (* 0.5d0 RANDOM-DISTRIBUTIONS::L1) (LOG RANDOM-DISTRIBUTIONS::M))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first argument of GENERIC-*

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/GIG.lisp
; in: DEFUN %RANDOM-GIG
;     (> RANDOM-DISTRIBUTIONS::Y 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (LOG RANDOM-DISTRIBUTIONS::Y)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a DOUBLE-FLOAT.

;     (/ RANDOM-DISTRIBUTIONS::Y)
; ==>
;   (/ 1 (THE NUMBER RANDOM-DISTRIBUTIONS::Y))
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The second argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a INTEGER.

;     (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA
;        (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y)))
; ==>
;   (* (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA)
;      (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y)))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a (OR (RATIONAL (0)) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)), not a INTEGER.

;     (/ RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::ALPHA)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a SINGLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a DOUBLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (>= (- (LOG RANDOM-DISTRIBUTIONS::R1))
;         (+ (* -0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::Y))
;            (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA
;               (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y)))
;            RANDOM-DISTRIBUTIONS::C))
; --> OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The second argument is a REAL, not a RATIONAL.

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

;     (* RANDOM-DISTRIBUTIONS::A
;        (/ RANDOM-DISTRIBUTIONS::R2 RANDOM-DISTRIBUTIONS::R1))
; 
; note: forced to do GENERIC-* (cost 30)
;       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 NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (+ RANDOM-DISTRIBUTIONS::M
;        (* RANDOM-DISTRIBUTIONS::A
;           (/ RANDOM-DISTRIBUTIONS::R2 RANDOM-DISTRIBUTIONS::R1))
;        (* RANDOM-DISTRIBUTIONS::B
;           (/ (- 1.0d0 RANDOM-DISTRIBUTIONS::R2) RANDOM-DISTRIBUTIONS::R1)))
; --> + 
; ==>
;   (+ RANDOM-DISTRIBUTIONS::M
;      (* RANDOM-DISTRIBUTIONS::A
;         (/ RANDOM-DISTRIBUTIONS::R2 RANDOM-DISTRIBUTIONS::R1)))
; 
; 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 NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (* RANDOM-DISTRIBUTIONS::B
;        (/ (- 1.0d0 RANDOM-DISTRIBUTIONS::R2) RANDOM-DISTRIBUTIONS::R1))
; 
; note: forced to do GENERIC-* (cost 30)
;       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 NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (+ RANDOM-DISTRIBUTIONS::M
;        (* RANDOM-DISTRIBUTIONS::A
;           (/ RANDOM-DISTRIBUTIONS::R2 RANDOM-DISTRIBUTIONS::R1))
;        (* RANDOM-DISTRIBUTIONS::B
;           (/ (- 1.0d0 RANDOM-DISTRIBUTIONS::R2) RANDOM-DISTRIBUTIONS::R1)))
; ==>
;   (+
;    (+ RANDOM-DISTRIBUTIONS::M
;       (* RANDOM-DISTRIBUTIONS::A
;          (/ RANDOM-DISTRIBUTIONS::R2 RANDOM-DISTRIBUTIONS::R1)))
;    (* RANDOM-DISTRIBUTIONS::B
;       (/ (- 1.0d0 RANDOM-DISTRIBUTIONS::R2) RANDOM-DISTRIBUTIONS::R1)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (> RANDOM-DISTRIBUTIONS::Y 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.

;     (* -0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::Y))
; --> * 
; ==>
;   (* -0.5d0 RANDOM-DISTRIBUTIONS::L1)
; 
; note: forced to do GENERIC-* (cost 30)
;       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 NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

; ==>
;   (* (* -0.5d0 RANDOM-DISTRIBUTIONS::L1) (LOG RANDOM-DISTRIBUTIONS::Y))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a FLOAT, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a FLOAT, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA
;        (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y)))
; --> * 
; ==>
;   (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA)
; 
; note: forced to do GENERIC-* (cost 30)
;       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 NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a DOUBLE-FLOAT.
;       The second argument is a (OR (RATIONAL 0) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (RATIONAL (0)) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a SINGLE-FLOAT.
;       The second argument is a (OR (RATIONAL 0) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR (RATIONAL (0)) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA
;        (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y)))
; ==>
;   (* (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA)
;      (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y)))
; 
; 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 (OR (RATIONAL (0)) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       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 (OR (RATIONAL (0)) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (+ (* -0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::Y))
;        (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA
;           (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y)))
;        RANDOM-DISTRIBUTIONS::C)
; --> + 
; ==>
;   (+ (* -0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::Y))
;      (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA
;         (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; ==>
;   (+
;    (+ (* -0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::Y))
;       (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA
;          (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y))))
;    RANDOM-DISTRIBUTIONS::C)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (>= (- (LOG RANDOM-DISTRIBUTIONS::R1))
;         (+ (* -0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::Y))
;            (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA
;               (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y)))
;            RANDOM-DISTRIBUTIONS::C))
; --> OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The second argument is a REAL, not a DOUBLE-FLOAT.

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

;     (/ RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::ALPHA)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (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 &REST T).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (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 &REST T).

;     (* RANDOM-DISTRIBUTIONS::A
;        (/ RANDOM-DISTRIBUTIONS::R2 RANDOM-DISTRIBUTIONS::R1))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*

;     (* RANDOM-DISTRIBUTIONS::B
;        (/ (- 1.0d0 RANDOM-DISTRIBUTIONS::R2) RANDOM-DISTRIBUTIONS::R1))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*

;     (- (LOG RANDOM-DISTRIBUTIONS::R1))
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (LOG RANDOM-DISTRIBUTIONS::R1)))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first result of inline float arithmetic

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/GIG.lisp
; in: DEFUN RANDOM-GIG
;     (< RANDOM-DISTRIBUTIONS::CHI 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (< RANDOM-DISTRIBUTIONS::PSI 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (COERCE LAMBDA 'DOUBLE-FLOAT)
; --> THE 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.

;     (COERCE RANDOM-DISTRIBUTIONS::CHI 'DOUBLE-FLOAT)
; --> THE 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.

;     (COERCE RANDOM-DISTRIBUTIONS::PSI 'DOUBLE-FLOAT)
; --> THE 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.

;     (RANDOM-DISTRIBUTIONS::%RANDOM-GIG RANDOM-DISTRIBUTIONS::L1
;      RANDOM-DISTRIBUTIONS::ALPHA RANDOM-DISTRIBUTIONS::BETA
;      RANDOM-DISTRIBUTIONS::M RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B
;      RANDOM-DISTRIBUTIONS::C)
; --> BLOCK LET TAGBODY LET* WHEN IF AND IF 
; ==>
;   (> RANDOM-DISTRIBUTIONS::Y 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + + + * * 
; ==>
;   (LOG RANDOM-DISTRIBUTIONS::Y)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a DOUBLE-FLOAT.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + + + * * + / 
; ==>
;   (/ 1 (THE NUMBER RANDOM-DISTRIBUTIONS::Y))
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The second argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a INTEGER.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + + + * 
; ==>
;   (* (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA)
;      (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y)))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a (OR (RATIONAL (0)) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)), not a INTEGER.

; --> BLOCK LET 
; ==>
;   (/ RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::ALPHA)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a SINGLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a DOUBLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a INTEGER.The second argument is a NUMBER, not a INTEGER.

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

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

;     (< RANDOM-DISTRIBUTIONS::CHI 0)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       etc.

;     (< RANDOM-DISTRIBUTIONS::PSI 0)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       etc.

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

;     (COERCE RANDOM-DISTRIBUTIONS::CHI 'DOUBLE-FLOAT)
; --> THE 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::X)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a (SIGNED-BYTE 64).

;     (COERCE RANDOM-DISTRIBUTIONS::PSI 'DOUBLE-FLOAT)
; --> THE 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::X)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a (SIGNED-BYTE 64).

;     (RANDOM-DISTRIBUTIONS::%RANDOM-GIG RANDOM-DISTRIBUTIONS::L1
;      RANDOM-DISTRIBUTIONS::ALPHA RANDOM-DISTRIBUTIONS::BETA
;      RANDOM-DISTRIBUTIONS::M RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B
;      RANDOM-DISTRIBUTIONS::C)
; --> BLOCK LET TAGBODY LET* SETF SETQ THE + + + 
; ==>
;   (* RANDOM-DISTRIBUTIONS::A
;      (/ RANDOM-DISTRIBUTIONS::R2 RANDOM-DISTRIBUTIONS::R1))
; 
; note: forced to do GENERIC-* (cost 30)
;       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 NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

; --> BLOCK LET TAGBODY LET* SETF SETQ THE + + 
; ==>
;   (+ RANDOM-DISTRIBUTIONS::M
;      (* RANDOM-DISTRIBUTIONS::A
;         (/ RANDOM-DISTRIBUTIONS::R2 RANDOM-DISTRIBUTIONS::R1)))
; 
; 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 NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; ==>
;   (* RANDOM-DISTRIBUTIONS::B
;      (/ (- 1.0d0 RANDOM-DISTRIBUTIONS::R2) RANDOM-DISTRIBUTIONS::R1))
; 
; note: forced to do GENERIC-* (cost 30)
;       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 NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

; --> BLOCK LET TAGBODY LET* SETF SETQ THE + 
; ==>
;   (+
;    (+ RANDOM-DISTRIBUTIONS::M
;       (* RANDOM-DISTRIBUTIONS::A
;          (/ RANDOM-DISTRIBUTIONS::R2 RANDOM-DISTRIBUTIONS::R1)))
;    (* RANDOM-DISTRIBUTIONS::B
;       (/ (- 1.0d0 RANDOM-DISTRIBUTIONS::R2) RANDOM-DISTRIBUTIONS::R1)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF 
; ==>
;   (> RANDOM-DISTRIBUTIONS::Y 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.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + + + * * 
; ==>
;   (* -0.5d0 RANDOM-DISTRIBUTIONS::L1)
; 
; note: forced to do GENERIC-* (cost 30)
;       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 NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + + + * 
; ==>
;   (* (* -0.5d0 RANDOM-DISTRIBUTIONS::L1) (LOG RANDOM-DISTRIBUTIONS::Y))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a FLOAT, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a FLOAT, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + + + * * 
; ==>
;   (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA)
; 
; note: forced to do GENERIC-* (cost 30)
;       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 NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

; ==>
;   (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a DOUBLE-FLOAT.
;       The second argument is a (OR (RATIONAL 0) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (RATIONAL (0)) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a SINGLE-FLOAT.
;       The second argument is a (OR (RATIONAL 0) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR (RATIONAL (0)) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + + + * 
; ==>
;   (* (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA)
;      (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y)))
; 
; 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 (OR (RATIONAL (0)) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       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 (OR (RATIONAL (0)) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + + 
; ==>
;   (+ (* -0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::Y))
;      (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA
;         (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + 
; ==>
;   (+
;    (+ (* -0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::Y))
;       (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA
;          (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y))))
;    RANDOM-DISTRIBUTIONS::C)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

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

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

; --> BLOCK LET 
; ==>
;   (/ RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::ALPHA)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (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 &REST T).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (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 &REST T).

; --> BLOCK LET TAGBODY LET* SETF SETQ THE + + + 
; ==>
;   (* RANDOM-DISTRIBUTIONS::A
;      (/ RANDOM-DISTRIBUTIONS::R2 RANDOM-DISTRIBUTIONS::R1))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*

; --> BLOCK LET TAGBODY LET* SETF SETQ THE + + 
; ==>
;   (* RANDOM-DISTRIBUTIONS::B
;      (/ (- 1.0d0 RANDOM-DISTRIBUTIONS::R2) RANDOM-DISTRIBUTIONS::R1))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= - 
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (LOG RANDOM-DISTRIBUTIONS::R1)))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first result of inline float arithmetic

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/GIG.lisp
; in: DEFUN MAKE-RANDOM-VARIABLE-GIG
;     (< RANDOM-DISTRIBUTIONS::CHI 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (< RANDOM-DISTRIBUTIONS::PSI 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (COERCE LAMBDA 'DOUBLE-FLOAT)
; --> THE 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.

;     (COERCE RANDOM-DISTRIBUTIONS::CHI 'DOUBLE-FLOAT)
; --> THE 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.

;     (COERCE RANDOM-DISTRIBUTIONS::PSI 'DOUBLE-FLOAT)
; --> THE 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.

;     (RANDOM-DISTRIBUTIONS::%RANDOM-GIG RANDOM-DISTRIBUTIONS::L1
;      RANDOM-DISTRIBUTIONS::ALPHA RANDOM-DISTRIBUTIONS::BETA
;      RANDOM-DISTRIBUTIONS::M RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B
;      RANDOM-DISTRIBUTIONS::C)
; --> BLOCK LET TAGBODY LET* WHEN IF AND IF 
; ==>
;   (> RANDOM-DISTRIBUTIONS::Y 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + + + * * 
; ==>
;   (LOG RANDOM-DISTRIBUTIONS::Y)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a DOUBLE-FLOAT.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + + + * * + / 
; ==>
;   (/ 1 (THE NUMBER RANDOM-DISTRIBUTIONS::Y))
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The second argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a INTEGER.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + + + * 
; ==>
;   (* (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA)
;      (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y)))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a (OR (RATIONAL (0)) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)), not a INTEGER.

; --> BLOCK LET 
; ==>
;   (/ RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::ALPHA)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a SINGLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a DOUBLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a INTEGER.The second argument is a NUMBER, not a INTEGER.

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

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

; --> BLOCK LET TAGBODY LET* SETF SETQ THE + + + 
; ==>
;   (* RANDOM-DISTRIBUTIONS::A
;      (/ RANDOM-DISTRIBUTIONS::R2 RANDOM-DISTRIBUTIONS::R1))
; 
; note: forced to do GENERIC-* (cost 30)
;       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 NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

; --> BLOCK LET TAGBODY LET* SETF SETQ THE + + 
; ==>
;   (+ RANDOM-DISTRIBUTIONS::M
;      (* RANDOM-DISTRIBUTIONS::A
;         (/ RANDOM-DISTRIBUTIONS::R2 RANDOM-DISTRIBUTIONS::R1)))
; 
; 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 NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; ==>
;   (* RANDOM-DISTRIBUTIONS::B
;      (/ (- 1.0d0 RANDOM-DISTRIBUTIONS::R2) RANDOM-DISTRIBUTIONS::R1))
; 
; note: forced to do GENERIC-* (cost 30)
;       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 NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

; --> BLOCK LET TAGBODY LET* SETF SETQ THE + 
; ==>
;   (+
;    (+ RANDOM-DISTRIBUTIONS::M
;       (* RANDOM-DISTRIBUTIONS::A
;          (/ RANDOM-DISTRIBUTIONS::R2 RANDOM-DISTRIBUTIONS::R1)))
;    (* RANDOM-DISTRIBUTIONS::B
;       (/ (- 1.0d0 RANDOM-DISTRIBUTIONS::R2) RANDOM-DISTRIBUTIONS::R1)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF 
; ==>
;   (> RANDOM-DISTRIBUTIONS::Y 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.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + + + * * 
; ==>
;   (* -0.5d0 RANDOM-DISTRIBUTIONS::L1)
; 
; note: forced to do GENERIC-* (cost 30)
;       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 NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + + + * 
; ==>
;   (* (* -0.5d0 RANDOM-DISTRIBUTIONS::L1) (LOG RANDOM-DISTRIBUTIONS::Y))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a FLOAT, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a FLOAT, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + + + * * 
; ==>
;   (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA)
; 
; note: forced to do GENERIC-* (cost 30)
;       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 NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

; ==>
;   (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a DOUBLE-FLOAT.
;       The second argument is a (OR (RATIONAL 0) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (RATIONAL (0)) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a SINGLE-FLOAT.
;       The second argument is a (OR (RATIONAL 0) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (OR (RATIONAL (0)) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + + + * 
; ==>
;   (* (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA)
;      (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y)))
; 
; 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 (OR (RATIONAL (0)) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       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 (OR (RATIONAL (0)) (SINGLE-FLOAT 0.0) (DOUBLE-FLOAT 0.0d0)), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + + 
; ==>
;   (+ (* -0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::Y))
;      (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA
;         (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + 
; ==>
;   (+
;    (+ (* -0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::Y))
;       (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA
;          (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y))))
;    RANDOM-DISTRIBUTIONS::C)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

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

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

; --> BLOCK LET 
; ==>
;   (/ RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::ALPHA)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (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 &REST T).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (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 &REST T).

;     (< RANDOM-DISTRIBUTIONS::CHI 0)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       etc.

;     (< RANDOM-DISTRIBUTIONS::PSI 0)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       etc.

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

;     (COERCE RANDOM-DISTRIBUTIONS::CHI 'DOUBLE-FLOAT)
; --> THE 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::X)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a (SIGNED-BYTE 64).

;     (COERCE RANDOM-DISTRIBUTIONS::PSI 'DOUBLE-FLOAT)
; --> THE 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::X)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a (SIGNED-BYTE 64).

;     (RANDOM-DISTRIBUTIONS::%RANDOM-GIG RANDOM-DISTRIBUTIONS::L1
;      RANDOM-DISTRIBUTIONS::ALPHA RANDOM-DISTRIBUTIONS::BETA
;      RANDOM-DISTRIBUTIONS::M RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B
;      RANDOM-DISTRIBUTIONS::C)
; --> BLOCK LET TAGBODY LET* SETF SETQ THE + + + 
; ==>
;   (* RANDOM-DISTRIBUTIONS::A
;      (/ RANDOM-DISTRIBUTIONS::R2 RANDOM-DISTRIBUTIONS::R1))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*

; --> BLOCK LET TAGBODY LET* SETF SETQ THE + + 
; ==>
;   (* RANDOM-DISTRIBUTIONS::B
;      (/ (- 1.0d0 RANDOM-DISTRIBUTIONS::R2) RANDOM-DISTRIBUTIONS::R1))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= - 
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (LOG RANDOM-DISTRIBUTIONS::R1)))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first result of inline float arithmetic

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/GIG.lisp
; in: DEFUN TEST-GIG-RANGE
;     (> RANDOM-DISTRIBUTIONS::X 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (LOOP RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::I RANDOM-DISTRIBUTIONS::FROM 0 RANDOM-DISTRIBUTIONS::TO 100000
;           RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::X = (FUNCALL
;                                                                RANDOM-DISTRIBUTIONS::R)
;           RANDOM-DISTRIBUTIONS::COUNTING ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-MINIMAX-VALUE LET 
; --> SB-LOOP::WITH-MINIMAX-VALUE LET TAGBODY 
; --> SB-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN IF OR LET IF < IF 
; ==>
;   (< #:LOOP-MAXMIN-TEMP-0 MIN)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.

; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-MINIMAX-VALUE LET 
; --> SB-LOOP::WITH-MINIMAX-VALUE LET TAGBODY 
; --> SB-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN IF OR LET IF > IF 
; ==>
;   (> #:LOOP-MAXMIN-TEMP-2 MAX)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a REAL, not a RATIONAL.

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

;     (LOOP RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::I RANDOM-DISTRIBUTIONS::FROM 0 RANDOM-DISTRIBUTIONS::TO 100000
;           RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::X = (FUNCALL
;                                                                RANDOM-DISTRIBUTIONS::R)
;           RANDOM-DISTRIBUTIONS::COUNTING ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-MINIMAX-VALUE LET 
; --> SB-LOOP::WITH-MINIMAX-VALUE LET TAGBODY 
; --> SB-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN IF OR LET IF < IF 
; ==>
;   (< #:LOOP-MAXMIN-TEMP-0 MIN)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-MINIMAX-VALUE LET 
; --> SB-LOOP::WITH-MINIMAX-VALUE LET TAGBODY 
; --> SB-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN IF OR LET IF > IF 
; ==>
;   (> #:LOOP-MAXMIN-TEMP-2 MAX)
; 
; 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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/91d4779af0ce0a9d62364950780ac2d7ded03316/cl-randist-20200317-git/GIG.lisp
; in: DEFUN TEST-GIG-SPEED
;     (> RANDOM-DISTRIBUTIONS::X 0)
; 
; note: forced to do FAST-IF->-ZERO (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (LOOP RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::I RANDOM-DISTRIBUTIONS::FROM 0 RANDOM-DISTRIBUTIONS::TO 100000
;           RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::X = (RANDOM-DISTRIBUTIONS:RANDOM-POISSON
;                                                                (RANDOM-DISTRIBUTIONS:RANDOM-GIG
;                                                                 -0.7277 0.0417
;                                                                 0.0016))
;           RANDOM-DISTRIBUTIONS::COUNTING ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-MINIMAX-VALUE LET 
; --> SB-LOOP::WITH-MINIMAX-VALUE LET TAGBODY 
; --> SB-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN IF OR LET IF < IF 
; ==>
;   (< #:LOOP-MAXMIN-TEMP-0 MIN)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.

; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-MINIMAX-VALUE LET 
; --> SB-LOOP::WITH-MINIMAX-VALUE LET TAGBODY 
; --> SB-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN IF OR LET IF > IF 
; ==>
;   (> #:LOOP-MAXMIN-TEMP-2 MAX)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/specialized-function/d7619d1a8824204600e1de08b8a618a4e89f7d97/specialized-function-20200317-git/src/1common.lisp
; in: DEFUN UPGRADED-OBJECT-TYPE
;     'COMPLEX
; 
; note: deleting unreachable code

;     '(COMPLEX LONG-FLOAT)
; 
; note: deleting unreachable code

;     '(COMPLEX SINGLE-FLOAT)
; 
; note: deleting unreachable code

;     'LONG-FLOAT
; 
; note: deleting unreachable code

;     'SINGLE-FLOAT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/1constants.lisp
; in: DEFUN MOST-POSITIVE-VALUE
;     (CASE NUMCL.IMPL::*NUMCL-DEFAULT-FLOAT-FORMAT*
;       (SHORT-FLOAT MOST-POSITIVE-SHORT-FLOAT)
;       (SINGLE-FLOAT MOST-POSITIVE-SINGLE-FLOAT)
;       (DOUBLE-FLOAT MOST-POSITIVE-DOUBLE-FLOAT)
;       (LONG-FLOAT MOST-POSITIVE-LONG-FLOAT))
; --> LET COND IF IF IF PROGN 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> LET COND IF PROGN 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> LET COND IF IF IF PROGN 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> LET COND IF PROGN 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/1constants.lisp
; in: DEFUN MOST-NEGATIVE-VALUE
;     (CASE NUMCL.IMPL::*NUMCL-DEFAULT-FLOAT-FORMAT*
;       (SHORT-FLOAT MOST-NEGATIVE-SHORT-FLOAT)
;       (SINGLE-FLOAT MOST-NEGATIVE-SINGLE-FLOAT)
;       (DOUBLE-FLOAT MOST-NEGATIVE-DOUBLE-FLOAT)
;       (LONG-FLOAT MOST-NEGATIVE-LONG-FLOAT))
; --> LET COND IF IF IF PROGN 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> LET COND IF PROGN 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> LET COND IF IF IF PROGN 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> LET COND IF PROGN 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/1type.lisp
; in: DEFCONSTANT *NUMCL-DEFAULT-FLOAT-FORMAT*
;     (DEFCONSTANT NUMCL.IMPL::*NUMCL-DEFAULT-FLOAT-FORMAT*
;       'SINGLE-FLOAT
;       "The default format for numcl arrays. Bignums and ratios are coerced into this type
;   during computation.")
; --> EVAL-WHEN 
; ==>
;   (SB-C::%DEFCONSTANT 'NUMCL.IMPL::*NUMCL-DEFAULT-FLOAT-FORMAT* 'SINGLE-FLOAT
;                       (SB-C:SOURCE-LOCATION)
;                       '"The default format for numcl arrays. Bignums and ratios are coerced into this type
; during computation.")
; 
; caught STYLE-WARNING:
;   Defining (*NUMCL-DEFAULT-FLOAT-FORMAT*) as a constant, even though the name follows
;   the usual naming convention (names like *FOO*) for special variables

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/1type.lisp
; in: DEFUN FLOAT-SUBSTITUTION
;     (ERROR "this should not happen")
; ==>
;   "this should not happen"
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/1type.lisp
; in: DECLAIM (INLINE UB)
;     (DECLAIM (INLINE NUMCL.IMPL::UB))
; --> EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE NUMCL.IMPL::UB) (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming NUMCL.IMPL::UB to be INLINE, but 64 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/1type.lisp
; in: DECLAIM (INLINE SB)
;     (DECLAIM (INLINE NUMCL.IMPL::SB))
; --> EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE NUMCL.IMPL::SB) (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming NUMCL.IMPL::SB to be INLINE, but 64 calls to it were previously compiled. A declaration of NOTINLINE at the call sites 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 "numcl" "src" "1type">
STYLE-WARNING: Defining (*NUMCL-DEFAULT-FLOAT-FORMAT*) as a constant, even though the name follows
the usual naming convention (names like *FOO*) for special variables

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/2alias.lisp
; in: DEFUN FLATTEN
;     (THE LIST (ALEXANDRIA.1.0.0:FLATTEN NUMCL.IMPL::A))
; 
; note: type assertion too complex to check:
; (VALUES &OPTIONAL LIST &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/2aref.lisp
; in: DEFUN NUMCL.EXPORTED:AREF
;     (NUMCL.EXPORTED:SHAPE ARRAY)
; --> BLOCK ETYPECASE LET COND IF IF IF PROGN LIST CONS LENGTH 
; ==>
;   ARRAY
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/2aref.lisp
; in: DEFUN %AREF
;     (TRIVIA.LEVEL2:EMATCH NUMCL.IMPL::SUBSCRIPTS
;       (NIL ARRAY)
;       ((LIST*
;         (NUMCL.IMPL::SUB NUMCL.IMPL::START NUMCL.IMPL::STOP STEP
;                          NUMCL.IMPL::WIDTH NUMCL.EXPORTED:FULL
;                          NUMCL.IMPL::CONTIGUOUS)
;         REST)
;        (COND ((= 1 NUMCL.IMPL::WIDTH) (NUMCL.IMPL::%AREF # REST))
;              ((AND NUMCL.EXPORTED:FULL #) ARRAY)
;              ((AND NUMCL.IMPL::CONTIGUOUS #)
;               (NUMCL.IMPL::%DISPLACE-RANGE ARRAY NUMCL.IMPL::START
;                NUMCL.IMPL::STOP))
;              (T (OR # #)))))
; --> TRIVIA.LEVEL2:MATCH2 TRIVIA.LEVEL2:MATCH2+ 
; ==>
;   (TRIVIA.LEVEL2:MATCH2*+ (NUMCL.IMPL::SUBSCRIPTS)
;       (T)
;     ((NIL) ARRAY)
;     (((LIST*
;        (NUMCL.IMPL::SUB NUMCL.IMPL::START NUMCL.IMPL::STOP STEP
;                         NUMCL.IMPL::WIDTH NUMCL.EXPORTED:FULL
;                         NUMCL.IMPL::CONTIGUOUS)
;        REST))
;      (COND ((= 1 NUMCL.IMPL::WIDTH) (NUMCL.IMPL::%AREF # REST))
;            ((AND NUMCL.EXPORTED:FULL #) ARRAY)
;            ((AND NUMCL.IMPL::CONTIGUOUS #)
;             (NUMCL.IMPL::%DISPLACE-RANGE ARRAY NUMCL.IMPL::START
;              NUMCL.IMPL::STOP))
;            (T (OR # #))))
;     ((#:OTHERWISE0)
;      (ERROR 'TRIVIA.LEVEL2:MATCH-ERROR :PATTERN '((NIL ARRAY) (# #)) :VALUES
;             (LIST #:OTHERWISE0))))
; 
; caught STYLE-WARNING:
;   Calling #<FUNCTION SUB-START> failed, but not by program-error (TYPE-ERROR).
;   Trivia probed candidate function #<FUNCTION SUB-START> by calling it with 
;   a single dummy argument 42. The call may fail due to various reasons,
;   but program-error is a strong indication of not being unary.
;    In order to disable this probing, run (SETF *ARITY-CHECK-BY-TEST-CALL* NIL) .
;   
;   Note: This style warning is shown only once.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/2aref.lisp
; in: DECLAIM (INLINE ENSURE-SINGLETON)
;     (DECLAIM (INLINE NUMCL.IMPL::ENSURE-SINGLETON))
; --> EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE NUMCL.IMPL::ENSURE-SINGLETON)
;                    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming NUMCL.IMPL::ENSURE-SINGLETON 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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/2aref.lisp
; in: DEFUN (SETF NUMCL.EXPORTED:AREF)
;     (NUMCL.EXPORTED:SHAPE ARRAY)
; --> BLOCK ETYPECASE LET COND IF IF IF PROGN LIST CONS LENGTH 
; ==>
;   ARRAY
; 
; note: deleting unreachable code

;     (NUMCL.EXPORTED:ASARRAY NUMCL.IMPL::NEWVAR :TYPE TYPE)
; 
; note: could not stack allocate: (ASARRAY NEWVAR :TYPE TYPE)
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "numcl" "src" "2aref">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/2typeinfer.lisp
; in: LISP-NAMESPACE:DEFINE-NAMESPACE INFERER
;     (LISP-NAMESPACE:DEFINE-NAMESPACE NUMCL.IMPL::INFERER (OR SYMBOL FUNCTION) NIL
;                                      "namespace for type inference")
; --> EVAL-WHEN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA NUMCL.IMPL::SYMBOL-INFERER
;         (SYMBOL &OPTIONAL
;          (LISP-NAMESPACE::DEFAULT NIL LISP-NAMESPACE::DEFAULT-SUPPLIED-P))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       "Automatically defined getter function. When DEFAULT is supplied, the value is set automatically."
;       (BLOCK NUMCL.IMPL::SYMBOL-INFERER
;         (MULTIPLE-VALUE-BIND (LISP-NAMESPACE::VALUE LISP-NAMESPACE::FOUND)
;             (GETHASH SYMBOL NUMCL.IMPL::*INFERER-TABLE*)
;           (IF LISP-NAMESPACE::FOUND
;               LISP-NAMESPACE::VALUE
;               (IF LISP-NAMESPACE::DEFAULT-SUPPLIED-P
;                   #
;                   #)))))
; 
; note: type assertion too complex to check:
; (VALUES &OPTIONAL (OR SYMBOL FUNCTION) &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/2typeinfer.lisp
; in: DEFUN ACOSH-INFERER
;     (DEFUN NUMCL.IMPL::ACOSH-INFERER (NUMCL.IMPL::X)
;       (NUMCL.IMPL::INTERPRET-TYPE `(* 2 (LOG (+ # #)))))
; --> PROGN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA NUMCL.IMPL::ACOSH-INFERER
;         (NUMCL.IMPL::X)
;       (BLOCK NUMCL.IMPL::ACOSH-INFERER
;         (NUMCL.IMPL::INTERPRET-TYPE `(* 2 (LOG #)))))
; 
; caught STYLE-WARNING:
;   The variable X is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "numcl" "src" "2typeinfer">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/3array.lisp
; in: DEFUN ASARRAY
;     (NUMCL.IMPL::%MAKE-ARRAY NUMCL.EXPORTED:SHAPE :ELEMENT-TYPE TYPE)
; --> BLOCK IF NUMCL.IMPL::LET LET * CEILING IF 
; ==>
;   NUMCL.EXPORTED:SHAPE
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/3array.lisp
; in: DEFUN INFER-TYPE-FROM-CONTENT
;     (NUMCL.IMPL::STRICT-TYPE-OF NUMCL.IMPL::X)
; --> BLOCK ETYPECASE LET COND IF IF IF IF IF IF IF IF PROGN TYPE-OF 
; ==>
;   NUMCL.IMPL::X
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/3zeros.lisp
; in:
;      DECLAIM (INLINE EMPTY EMPTY-LIKE FULL FULL-LIKE ZEROS ZEROS-LIKE ONES ONES-LIKE)
;     (DECLAIM
;      (INLINE NUMCL.EXPORTED:EMPTY NUMCL.EXPORTED:EMPTY-LIKE NUMCL.EXPORTED:FULL
;       NUMCL.EXPORTED:FULL-LIKE NUMCL.EXPORTED:ZEROS NUMCL.EXPORTED:ZEROS-LIKE
;       NUMCL.EXPORTED:ONES NUMCL.EXPORTED:ONES-LIKE))
; --> EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM
;    '(INLINE NUMCL.EXPORTED:EMPTY NUMCL.EXPORTED:EMPTY-LIKE NUMCL.EXPORTED:FULL
;      NUMCL.EXPORTED:FULL-LIKE NUMCL.EXPORTED:ZEROS NUMCL.EXPORTED:ZEROS-LIKE
;      NUMCL.EXPORTED:ONES NUMCL.EXPORTED:ONES-LIKE)
;    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming NUMCL.EXPORTED:EMPTY 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.
; 
; caught STYLE-WARNING:
;   Proclaiming NUMCL.EXPORTED:EMPTY-LIKE to be INLINE, but 2 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/3zeros.lisp
; in: DEFUN FULL-LIKE
;     (NUMCL.EXPORTED:FULL (NUMCL.EXPORTED:SHAPE ARRAY)
;      (NUMCL.IMPL::%COERCE NUMCL.IMPL::VALUE TYPE) :TYPE TYPE)
; --> IF SB-C::WITH-SOURCE-FORM TYPE TYPE-OF 
; ==>
;   NUMCL.IMPL::VALUE
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/3zeros.lisp
; in: DEFUN ZEROS-LIKE
;     (NUMCL.EXPORTED:FULL-LIKE ARRAY (NUMCL.IMPL::%COERCE 0 TYPE) :TYPE TYPE)
; --> IF SB-C::WITH-SOURCE-FORM TYPE ARRAY-ELEMENT-TYPE 
; ==>
;   ARRAY
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/3zeros.lisp
; in: DEFUN ONES-LIKE
;     (NUMCL.EXPORTED:FULL-LIKE ARRAY (NUMCL.IMPL::%COERCE 1 TYPE) :TYPE TYPE)
; --> IF SB-C::WITH-SOURCE-FORM TYPE ARRAY-ELEMENT-TYPE 
; ==>
;   ARRAY
; 
; note: deleting unreachable code
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "numcl" "src" "3zeros">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/4concatenate.lisp
; in: DEFUN UNSTACK
;     (NUMCL.EXPORTED:SHAPE ARRAY)
; --> BLOCK ETYPECASE LET COND IF IF IF PROGN LIST CONS LENGTH 
; ==>
;   ARRAY
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN BROADCAST
;     (ARRAY-DISPLACEMENT NUMCL.IMPL::X)
; --> BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

;     (ARRAY-DISPLACEMENT NUMCL.IMPL::Y)
; --> BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in:
;      DECLAIM (INLINE NUMCL.EXPORTED:SIN NUMCL.EXPORTED:COS NUMCL.EXPORTED:TAN NUMCL.EXPORTED:ASIN NUMCL.EXPORTED:ACOS NUMCL.EXPORTED:ATAN NUMCL.EXPORTED:SINH NUMCL.EXPORTED:COSH NUMCL.EXPORTED:TANH NUMCL.EXPORTED:EXP NUMCL.EXPORTED:LOG ...)
;     (DECLAIM
;      (INLINE NUMCL.EXPORTED:SIN NUMCL.EXPORTED:COS NUMCL.EXPORTED:TAN
;       NUMCL.EXPORTED:ASIN NUMCL.EXPORTED:ACOS NUMCL.EXPORTED:ATAN
;       NUMCL.EXPORTED:SINH NUMCL.EXPORTED:COSH NUMCL.EXPORTED:TANH
;       NUMCL.EXPORTED:EXP NUMCL.EXPORTED:LOG ...))
; --> EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM
;    '(INLINE NUMCL.EXPORTED:SIN NUMCL.EXPORTED:COS NUMCL.EXPORTED:TAN
;      NUMCL.EXPORTED:ASIN NUMCL.EXPORTED:ACOS NUMCL.EXPORTED:ATAN
;      NUMCL.EXPORTED:SINH NUMCL.EXPORTED:COSH NUMCL.EXPORTED:TANH
;      NUMCL.EXPORTED:EXP NUMCL.EXPORTED:LOG ...)
;    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming NUMCL.EXPORTED:CONJUGATE to be INLINE, but 4 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFINE-SIMPLE-MAPPER NUMCL.EXPORTED:SQRT
;     (NUMCL.IMPL::DEFINE-SIMPLE-MAPPER NUMCL.EXPORTED:SQRT SQRT)
; --> DEFUN PROGN 
; ==>
;   (EVAL-WHEN (:COMPILE-TOPLEVEL)
;     (SB-C:%COMPILER-DEFUN 'NUMCL.EXPORTED:SQRT T NIL NIL))
; 
; caught WARNING:
;   Duplicate definition for NUMCL.EXPORTED:SQRT found in one file.
;   See also:
;     The ANSI Standard, Section 3.2.2.3

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in:
;      DECLAIM (INLINE NUMCL.EXPORTED:+ NUMCL.EXPORTED:- NUMCL.EXPORTED:* NUMCL.EXPORTED:/ NUMCL.EXPORTED:MAX NUMCL.EXPORTED:MIN CLIP)
;     (DECLAIM
;      (INLINE NUMCL.EXPORTED:+ NUMCL.EXPORTED:- NUMCL.EXPORTED:* NUMCL.EXPORTED:/
;       NUMCL.EXPORTED:MAX NUMCL.EXPORTED:MIN NUMCL.EXPORTED:CLIP))
; --> EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM
;    '(INLINE NUMCL.EXPORTED:+ NUMCL.EXPORTED:- NUMCL.EXPORTED:* NUMCL.EXPORTED:/
;      NUMCL.EXPORTED:MAX NUMCL.EXPORTED:MIN NUMCL.EXPORTED:CLIP)
;    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming NUMCL.EXPORTED:+ 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.
; 
; caught STYLE-WARNING:
;   Proclaiming NUMCL.EXPORTED:- 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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:+
;     (NUMCL.EXPORTED:BROADCAST '+ NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:*
;     (NUMCL.EXPORTED:BROADCAST '* NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:MAX
;     (NUMCL.EXPORTED:BROADCAST 'MAX NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:MIN
;     (NUMCL.EXPORTED:BROADCAST 'MIN NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:EXPT
;     (NUMCL.EXPORTED:BROADCAST 'EXPT NUMCL.IMPL::BASE NUMCL.EXPORTED:POWER)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:-
;     (NUMCL.EXPORTED:BROADCAST '- NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

;     (NUMCL.EXPORTED:BROADCAST '- 0 FIRST)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:/
;     (NUMCL.EXPORTED:BROADCAST '/ NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

;     (NUMCL.EXPORTED:BROADCAST '/ 1 FIRST)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN CLIP
;     (NUMCL.EXPORTED:BROADCAST 'MIN ARRAY MAX)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

;     (NUMCL.EXPORTED:BROADCAST 'MAX MIN (NUMCL.EXPORTED:BROADCAST 'MIN ARRAY MAX))
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:MOD
;     (NUMCL.EXPORTED:BROADCAST 'MOD NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:REM
;     (NUMCL.EXPORTED:BROADCAST 'REM NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:ROUND
;     (NUMCL.EXPORTED:BROADCAST 'ROUND NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:FLOOR
;     (NUMCL.EXPORTED:BROADCAST 'FLOOR NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:CEILING
;     (NUMCL.EXPORTED:BROADCAST 'CEILING NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:TRUNCATE
;     (NUMCL.EXPORTED:BROADCAST 'TRUNCATE NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:FROUND
;     (NUMCL.EXPORTED:BROADCAST 'FROUND NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:FFLOOR
;     (NUMCL.EXPORTED:BROADCAST 'FFLOOR NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:FCEILING
;     (NUMCL.EXPORTED:BROADCAST 'FCEILING NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:FTRUNCATE
;     (NUMCL.EXPORTED:BROADCAST 'FTRUNCATE NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN =/2
;     (NUMCL.EXPORTED:BROADCAST 'NUMCL.IMPL::=/BIT NUMCL.IMPL::X NUMCL.IMPL::Y
;      :ATOMIC #'=)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN /=/2
;     (NUMCL.EXPORTED:BROADCAST 'NUMCL.IMPL::/=/BIT NUMCL.IMPL::X NUMCL.IMPL::Y
;      :ATOMIC #'/=)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN <=/2
;     (NUMCL.EXPORTED:BROADCAST 'NUMCL.IMPL::<=/BIT NUMCL.IMPL::X NUMCL.IMPL::Y
;      :ATOMIC #'<=)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN >=/2
;     (NUMCL.EXPORTED:BROADCAST 'NUMCL.IMPL::>=/BIT NUMCL.IMPL::X NUMCL.IMPL::Y
;      :ATOMIC #'>=)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN </2
;     (NUMCL.EXPORTED:BROADCAST 'NUMCL.IMPL::</BIT NUMCL.IMPL::X NUMCL.IMPL::Y
;      :ATOMIC #'<)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN >/2
;     (NUMCL.EXPORTED:BROADCAST 'NUMCL.IMPL::>/BIT NUMCL.IMPL::X NUMCL.IMPL::Y
;      :ATOMIC #'>)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:=
;     (NUMCL.IMPL::BOOLEAN-WRAPPER NUMCL.IMPL::X NUMCL.IMPL::Y NUMCL.IMPL::MORE
;      #'NUMCL.IMPL::=/2 #'NUMCL.EXPORTED:=)
; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:/=
;     (NUMCL.IMPL::BOOLEAN-WRAPPER NUMCL.IMPL::X NUMCL.IMPL::Y NUMCL.IMPL::MORE
;      #'NUMCL.IMPL::/=/2 #'NUMCL.EXPORTED:/=)
; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:<=
;     (NUMCL.IMPL::BOOLEAN-WRAPPER NUMCL.IMPL::X NUMCL.IMPL::Y NUMCL.IMPL::MORE
;      #'NUMCL.IMPL::<=/2 #'NUMCL.EXPORTED:<=)
; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:>=
;     (NUMCL.IMPL::BOOLEAN-WRAPPER NUMCL.IMPL::X NUMCL.IMPL::Y NUMCL.IMPL::MORE
;      #'NUMCL.IMPL::>=/2 #'NUMCL.EXPORTED:>=)
; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:<
;     (NUMCL.IMPL::BOOLEAN-WRAPPER NUMCL.IMPL::X NUMCL.IMPL::Y NUMCL.IMPL::MORE
;      #'NUMCL.IMPL::</2 #'NUMCL.EXPORTED:<)
; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:>
;     (NUMCL.IMPL::BOOLEAN-WRAPPER NUMCL.IMPL::X NUMCL.IMPL::Y NUMCL.IMPL::MORE
;      #'NUMCL.IMPL::>/2 #'NUMCL.EXPORTED:>)
; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in:
;      DECLAIM (INLINE NUMCL.EXPORTED:LOGAND NUMCL.EXPORTED:LOGANDC1 NUMCL.EXPORTED:LOGANDC2 NUMCL.EXPORTED:LOGEQV NUMCL.EXPORTED:LOGIOR NUMCL.EXPORTED:LOGNAND NUMCL.EXPORTED:LOGNOR NUMCL.EXPORTED:LOGORC1 NUMCL.EXPORTED:LOGORC2 NUMCL.EXPORTED:LOGXOR NUMCL.EXPORTED:LOGNOT)
;     (DECLAIM
;      (INLINE NUMCL.EXPORTED:LOGAND NUMCL.EXPORTED:LOGANDC1
;       NUMCL.EXPORTED:LOGANDC2 NUMCL.EXPORTED:LOGEQV NUMCL.EXPORTED:LOGIOR
;       NUMCL.EXPORTED:LOGNAND NUMCL.EXPORTED:LOGNOR NUMCL.EXPORTED:LOGORC1
;       NUMCL.EXPORTED:LOGORC2 NUMCL.EXPORTED:LOGXOR NUMCL.EXPORTED:LOGNOT))
; --> EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM
;    '(INLINE NUMCL.EXPORTED:LOGAND NUMCL.EXPORTED:LOGANDC1
;      NUMCL.EXPORTED:LOGANDC2 NUMCL.EXPORTED:LOGEQV NUMCL.EXPORTED:LOGIOR
;      NUMCL.EXPORTED:LOGNAND NUMCL.EXPORTED:LOGNOR NUMCL.EXPORTED:LOGORC1
;      NUMCL.EXPORTED:LOGORC2 NUMCL.EXPORTED:LOGXOR NUMCL.EXPORTED:LOGNOT)
;    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming NUMCL.EXPORTED:LOGAND to be INLINE, but 7 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGAND
;     (NUMCL.EXPORTED:BROADCAST 'LOGAND NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGANDC1
;     (NUMCL.EXPORTED:BROADCAST 'LOGANDC1 NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGANDC2
;     (NUMCL.EXPORTED:BROADCAST 'LOGANDC2 NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGEQV
;     (NUMCL.EXPORTED:BROADCAST 'LOGEQV NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGIOR
;     (NUMCL.EXPORTED:BROADCAST 'LOGIOR NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGNAND
;     (NUMCL.EXPORTED:BROADCAST 'LOGNAND NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGNOR
;     (NUMCL.EXPORTED:BROADCAST 'LOGNOR NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGORC1
;     (NUMCL.EXPORTED:BROADCAST 'LOGORC1 NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGORC2
;     (NUMCL.EXPORTED:BROADCAST 'LOGORC2 NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGXOR
;     (NUMCL.EXPORTED:BROADCAST 'LOGXOR NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"
Unhandled UIOP/LISP-BUILD:COMPILE-FILE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING {1000560083}>: COMPILE-FILE-ERROR while compiling #<CL-SOURCE-FILE "numcl" "src" "5numeric">

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

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

numcl.test

WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-interpol/a82431c7ecb6a7c73f2ba9d4d18e23f65d0e3d0b/cl-interpol-20200317-git/cl-interpol.asd" contains definition for system "cl-interpol-test". Please only define "cl-interpol" and secondary systems with a name starting with "cl-interpol/" (e.g. "cl-interpol/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-ppcre/d6593d8f842bcf6af810ff93c6c02b757bd49ecf/cl-ppcre-20200317-git/cl-ppcre.asd" contains definition for system "cl-ppcre-test". Please only define "cl-ppcre" and secondary systems with a name starting with "cl-ppcre/" (e.g. "cl-ppcre/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/symbol-munger/a8589c60f470b8b280eacd9c983d96bc5f337341/symbol-munger-20200317-git/symbol-munger.asd" contains definition for system "symbol-munger-test". Please only define "symbol-munger" and secondary systems with a name starting with "symbol-munger/" (e.g. "symbol-munger/test") in that file.
STYLE-WARNING: Defining (*NUMCL-DEFAULT-FLOAT-FORMAT*) as a constant, even though the name follows
the usual naming convention (names like *FOO*) for special variables

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN BROADCAST
;     (ARRAY-DISPLACEMENT NUMCL.IMPL::X)
; --> BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

;     (ARRAY-DISPLACEMENT NUMCL.IMPL::Y)
; --> BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFINE-SIMPLE-MAPPER NUMCL.EXPORTED:SQRT
;     (NUMCL.IMPL::DEFINE-SIMPLE-MAPPER NUMCL.EXPORTED:SQRT SQRT)
; --> DEFUN PROGN 
; ==>
;   (EVAL-WHEN (:COMPILE-TOPLEVEL)
;     (SB-C:%COMPILER-DEFUN 'NUMCL.EXPORTED:SQRT T NIL NIL))
; 
; caught WARNING:
;   Duplicate definition for NUMCL.EXPORTED:SQRT found in one file.
;   See also:
;     The ANSI Standard, Section 3.2.2.3

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in:
;      DECLAIM (INLINE NUMCL.EXPORTED:+ NUMCL.EXPORTED:- NUMCL.EXPORTED:* NUMCL.EXPORTED:/ NUMCL.EXPORTED:MAX NUMCL.EXPORTED:MIN CLIP)
;     (DECLAIM
;      (INLINE NUMCL.EXPORTED:+ NUMCL.EXPORTED:- NUMCL.EXPORTED:* NUMCL.EXPORTED:/
;       NUMCL.EXPORTED:MAX NUMCL.EXPORTED:MIN NUMCL.EXPORTED:CLIP))
; --> EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM
;    '(INLINE NUMCL.EXPORTED:+ NUMCL.EXPORTED:- NUMCL.EXPORTED:* NUMCL.EXPORTED:/
;      NUMCL.EXPORTED:MAX NUMCL.EXPORTED:MIN NUMCL.EXPORTED:CLIP)
;    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming NUMCL.EXPORTED:+ 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.
; 
; caught STYLE-WARNING:
;   Proclaiming NUMCL.EXPORTED:- 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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:+
;     (NUMCL.EXPORTED:BROADCAST '+ NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:*
;     (NUMCL.EXPORTED:BROADCAST '* NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:MAX
;     (NUMCL.EXPORTED:BROADCAST 'MAX NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:MIN
;     (NUMCL.EXPORTED:BROADCAST 'MIN NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:EXPT
;     (NUMCL.EXPORTED:BROADCAST 'EXPT NUMCL.IMPL::BASE NUMCL.EXPORTED:POWER)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:-
;     (NUMCL.EXPORTED:BROADCAST '- NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

;     (NUMCL.EXPORTED:BROADCAST '- 0 FIRST)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:/
;     (NUMCL.EXPORTED:BROADCAST '/ NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

;     (NUMCL.EXPORTED:BROADCAST '/ 1 FIRST)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN CLIP
;     (NUMCL.EXPORTED:BROADCAST 'MIN ARRAY MAX)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

;     (NUMCL.EXPORTED:BROADCAST 'MAX MIN (NUMCL.EXPORTED:BROADCAST 'MIN ARRAY MAX))
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:MOD
;     (NUMCL.EXPORTED:BROADCAST 'MOD NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:REM
;     (NUMCL.EXPORTED:BROADCAST 'REM NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:ROUND
;     (NUMCL.EXPORTED:BROADCAST 'ROUND NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:FLOOR
;     (NUMCL.EXPORTED:BROADCAST 'FLOOR NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:CEILING
;     (NUMCL.EXPORTED:BROADCAST 'CEILING NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:TRUNCATE
;     (NUMCL.EXPORTED:BROADCAST 'TRUNCATE NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:FROUND
;     (NUMCL.EXPORTED:BROADCAST 'FROUND NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:FFLOOR
;     (NUMCL.EXPORTED:BROADCAST 'FFLOOR NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:FCEILING
;     (NUMCL.EXPORTED:BROADCAST 'FCEILING NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:FTRUNCATE
;     (NUMCL.EXPORTED:BROADCAST 'FTRUNCATE NUMBER NUMCL.IMPL::DIVISOR)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN =/2
;     (NUMCL.EXPORTED:BROADCAST 'NUMCL.IMPL::=/BIT NUMCL.IMPL::X NUMCL.IMPL::Y
;      :ATOMIC #'=)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN /=/2
;     (NUMCL.EXPORTED:BROADCAST 'NUMCL.IMPL::/=/BIT NUMCL.IMPL::X NUMCL.IMPL::Y
;      :ATOMIC #'/=)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN <=/2
;     (NUMCL.EXPORTED:BROADCAST 'NUMCL.IMPL::<=/BIT NUMCL.IMPL::X NUMCL.IMPL::Y
;      :ATOMIC #'<=)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN >=/2
;     (NUMCL.EXPORTED:BROADCAST 'NUMCL.IMPL::>=/BIT NUMCL.IMPL::X NUMCL.IMPL::Y
;      :ATOMIC #'>=)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN </2
;     (NUMCL.EXPORTED:BROADCAST 'NUMCL.IMPL::</BIT NUMCL.IMPL::X NUMCL.IMPL::Y
;      :ATOMIC #'<)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN >/2
;     (NUMCL.EXPORTED:BROADCAST 'NUMCL.IMPL::>/BIT NUMCL.IMPL::X NUMCL.IMPL::Y
;      :ATOMIC #'>)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:=
;     (NUMCL.IMPL::BOOLEAN-WRAPPER NUMCL.IMPL::X NUMCL.IMPL::Y NUMCL.IMPL::MORE
;      #'NUMCL.IMPL::=/2 #'NUMCL.EXPORTED:=)
; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:/=
;     (NUMCL.IMPL::BOOLEAN-WRAPPER NUMCL.IMPL::X NUMCL.IMPL::Y NUMCL.IMPL::MORE
;      #'NUMCL.IMPL::/=/2 #'NUMCL.EXPORTED:/=)
; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:<=
;     (NUMCL.IMPL::BOOLEAN-WRAPPER NUMCL.IMPL::X NUMCL.IMPL::Y NUMCL.IMPL::MORE
;      #'NUMCL.IMPL::<=/2 #'NUMCL.EXPORTED:<=)
; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:>=
;     (NUMCL.IMPL::BOOLEAN-WRAPPER NUMCL.IMPL::X NUMCL.IMPL::Y NUMCL.IMPL::MORE
;      #'NUMCL.IMPL::>=/2 #'NUMCL.EXPORTED:>=)
; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:<
;     (NUMCL.IMPL::BOOLEAN-WRAPPER NUMCL.IMPL::X NUMCL.IMPL::Y NUMCL.IMPL::MORE
;      #'NUMCL.IMPL::</2 #'NUMCL.EXPORTED:<)
; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:>
;     (NUMCL.IMPL::BOOLEAN-WRAPPER NUMCL.IMPL::X NUMCL.IMPL::Y NUMCL.IMPL::MORE
;      #'NUMCL.IMPL::>/2 #'NUMCL.EXPORTED:>)
; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> BLOCK NUMCL.IMPL::LET LET FUNCALL SB-C::%FUNCALL BLOCK 
; --> NUMCL.EXPORTED:BROADCAST LET COND IF THE NUMCL.IMPL::LET LET 
; --> NUMCL.IMPL::LET* LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in:
;      DECLAIM (INLINE NUMCL.EXPORTED:LOGAND NUMCL.EXPORTED:LOGANDC1 NUMCL.EXPORTED:LOGANDC2 NUMCL.EXPORTED:LOGEQV NUMCL.EXPORTED:LOGIOR NUMCL.EXPORTED:LOGNAND NUMCL.EXPORTED:LOGNOR NUMCL.EXPORTED:LOGORC1 NUMCL.EXPORTED:LOGORC2 NUMCL.EXPORTED:LOGXOR NUMCL.EXPORTED:LOGNOT)
;     (DECLAIM
;      (INLINE NUMCL.EXPORTED:LOGAND NUMCL.EXPORTED:LOGANDC1
;       NUMCL.EXPORTED:LOGANDC2 NUMCL.EXPORTED:LOGEQV NUMCL.EXPORTED:LOGIOR
;       NUMCL.EXPORTED:LOGNAND NUMCL.EXPORTED:LOGNOR NUMCL.EXPORTED:LOGORC1
;       NUMCL.EXPORTED:LOGORC2 NUMCL.EXPORTED:LOGXOR NUMCL.EXPORTED:LOGNOT))
; --> EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM
;    '(INLINE NUMCL.EXPORTED:LOGAND NUMCL.EXPORTED:LOGANDC1
;      NUMCL.EXPORTED:LOGANDC2 NUMCL.EXPORTED:LOGEQV NUMCL.EXPORTED:LOGIOR
;      NUMCL.EXPORTED:LOGNAND NUMCL.EXPORTED:LOGNOR NUMCL.EXPORTED:LOGORC1
;      NUMCL.EXPORTED:LOGORC2 NUMCL.EXPORTED:LOGXOR NUMCL.EXPORTED:LOGNOT)
;    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming NUMCL.EXPORTED:LOGAND to be INLINE, but 7 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGAND
;     (NUMCL.EXPORTED:BROADCAST 'LOGAND NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGANDC1
;     (NUMCL.EXPORTED:BROADCAST 'LOGANDC1 NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGANDC2
;     (NUMCL.EXPORTED:BROADCAST 'LOGANDC2 NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGEQV
;     (NUMCL.EXPORTED:BROADCAST 'LOGEQV NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGIOR
;     (NUMCL.EXPORTED:BROADCAST 'LOGIOR NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGNAND
;     (NUMCL.EXPORTED:BROADCAST 'LOGNAND NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGNOR
;     (NUMCL.EXPORTED:BROADCAST 'LOGNOR NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGORC1
;     (NUMCL.EXPORTED:BROADCAST 'LOGORC1 NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGORC2
;     (NUMCL.EXPORTED:BROADCAST 'LOGORC2 NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/42df2c309d09d378d3e3f5e27a2805520394fd52/numcl-20200317-git/src/5numeric.lisp
; in: DEFUN NUMCL.EXPORTED:LOGXOR
;     (NUMCL.EXPORTED:BROADCAST 'LOGXOR NUMCL.IMPL::X NUMCL.IMPL::Y)
; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"

; --> LET COND IF THE NUMCL.IMPL::LET LET NUMCL.IMPL::LET* LET* 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION MULTIPLE-VALUE-PROG1 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION 
; --> MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION MULTIPLE-VALUE-PROG1 PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL ARRAY-DISPLACEMENT BLOCK IF 
; ==>
;   (VALUES NIL 0)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL (INTEGER 0 0) &OPTIONAL), 
;            not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
;   See also:
;     The SBCL Manual, Node "Handling of Types"
Unhandled UIOP/LISP-BUILD:COMPILE-FILE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING {1000560083}>: COMPILE-FILE-ERROR while compiling #<CL-SOURCE-FILE "numcl" "src" "5numeric">

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {1000560083}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {1012BBB0D3}> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {1012BBB0D3}>)
2: (INVOKE-DEBUGGER #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {1012BBB0D3}>)
3: (ERROR UIOP/LISP-BUILD:COMPILE-FILE-ERROR :CONTEXT-FORMAT "~/asdf-action::format-action/" :CONTEXT-ARGUMENTS ((#<ASDF/LISP-ACTION:COMPILE-OP > . #<ASDF/LISP-ACTION:CL-SOURCE-FILE "numcl" "src" "5numeric">)))
4: (UIOP/LISP-BUILD:CHECK-LISP-COMPILE-RESULTS NIL T T "~/asdf-action::format-action/" ((#<ASDF/LISP-ACTION:COMPILE-OP > . #<ASDF/LISP-ACTION:CL-SOURCE-FILE "numcl" "src" "5numeric">)))
5: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "numcl" "src" "5numeric">)
6: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
7: ((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS :AROUND (T T)) #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "numcl" "src" "5numeric">) [fast-method]
8: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {100551F0D3}>) [fast-method]
9: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
10: ((:METHOD ASDF/PLAN:PERFORM-PLAN :AROUND (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {100551F0D3}>) [fast-method]
11: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "numcl.test"> :PLAN-CLASS NIL :PLAN-OPTIONS NIL) [fast-method]
12: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "numcl.test">)
13: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
14: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "numcl.test">) [fast-method]
15: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "numcl.test")
16: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
17: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "numcl.test") [fast-method]
18: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {100551749B}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
19: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
20: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {10054CF0AB}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
21: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "numcl.test") [fast-method]
22: (DEPCHECK::COMPUTE-DEPENDENCIES "numcl.test" "numcl.test")
23: (DEPCHECK::MAGIC "numcl.test" "numcl.test" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-GSJdf1Bh/depcheck-win.txt")
24: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "numcl.test" "numcl.test" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-GSJdf1Bh/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-GSJdf1Bh/depcheck-fail.txt"))
25: ((LAMBDA NIL :IN "/home/quicklisp/quicklisp/local-projects/quicklisp-controller/dumper-2SKVI5f7.lisp"))
26: ((FLET SB-UNIX::BODY :IN SAVE-LISP-AND-DIE))
27: ((FLET "WITHOUT-INTERRUPTS-BODY-14" :IN SAVE-LISP-AND-DIE))
28: ((LABELS SB-IMPL::RESTART-LISP :IN SAVE-LISP-AND-DIE))

unhandled condition in --disable-debugger mode, quitting
; 
; compilation unit aborted
;   caught 1 fatal ERROR condition
;   caught 1 WARNING condition
;   caught 91 STYLE-WARNING conditions