cl-containers

SBCL 1.4.4 / ASDF 3.3.1

cl-containers/with-variates

WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-variates/0ee1831ebbfe0c3efb4a5a02936f8a01b624abcc/cl-variates-20180202-darcs/cl-variates.asd" contains definition for system "variates-and-metacopy". Please only define "cl-variates" and secondary systems with a name starting with "cl-variates/" (e.g. "cl-variates/test") in that file.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-variates/0ee1831ebbfe0c3efb4a5a02936f8a01b624abcc/cl-variates-20180202-darcs/dev/variates.lisp
; in: DEFUN RANDOM-ELEMENT
;     (IF (OR (AND (CONSP SEQUENCE) (NULL SEQUENCE)) (ZEROP (LENGTH SEQUENCE)))
;         (VALUES NIL NIL)
;         (VALUES
;          (ELT SEQUENCE
;               (CL-VARIATES:RANDOM-RANGE CL-VARIATES::GENERATOR CL-VARIATES::START
;                CL-VARIATES::END))
;          T))
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-variates/0ee1831ebbfe0c3efb4a5a02936f8a01b624abcc/cl-variates-20180202-darcs/dev/variates.lisp
; in: DEFMETHOD NEXT-ELEMENT (RAN1-RANDOM-NUMBER-GENERATOR)
;     (DEFMETHOD CL-VARIATES:NEXT-ELEMENT
;                ((CL-VARIATES::RNG CL-VARIATES:RAN1-RANDOM-NUMBER-GENERATOR))
;       (DECLARE (OPTIMIZE SPEED))
;       (WITH-SLOTS (CL-VARIATES::IA CL-VARIATES::IM CL-VARIATES::AM
;                    CL-VARIATES::IQ CL-VARIATES::IR CL-VARIATES::NDIV
;                    CL-VARIATES::RNMX CL-VARIATES::IV CL-VARIATES::IY
;                    CL-VARIATES::INTERNAL-SEED)
;           CL-VARIATES::RNG
;         (LET ((CL-VARIATES::K #))
;           (SETF CL-VARIATES::INTERNAL-SEED #))
;         (WHEN (< CL-VARIATES::INTERNAL-SEED 0.0d0)
;           (SETF CL-VARIATES::INTERNAL-SEED #))
;         (LET ((CL-VARIATES::J #))
;           (SETF CL-VARIATES::IY #)
;           (SETF # CL-VARIATES::INTERNAL-SEED))
;         (LET ((CL-VARIATES::TEMP #))
;           (IF (> CL-VARIATES::TEMP CL-VARIATES::RNMX)
;               CL-VARIATES::RNMX
;               CL-VARIATES::TEMP))))
; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET LET LET - 
; ==>
;   (* (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::IA)
;      (- (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::INTERNAL-SEED)
;         (* CL-VARIATES::K (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::IQ))))
; 
; 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.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET IF 
; ==>
;   (< (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::INTERNAL-SEED) 0.0d0)
; 
; note: unable to open-code RATIONAL to FLOAT comparison due to type uncertainty: The first argument is a REAL, not a RATIONAL.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FLOOR 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (TRUNCATE NUMBER SB-C::DIVISOR)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a (OR DOUBLE-FLOAT SINGLE-FLOAT INTEGER).

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET 
; ==>
;   (* (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::AM)
;      (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::IY))
; 
; 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.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET IF 
; ==>
;   (> CL-VARIATES::TEMP (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::RNMX))
; 
; 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.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FLOOR 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF NOT IF ZEROP 
; ==>
;   (= REM 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FLOOR 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF MINUSP 
; ==>
;   (< SB-C::DIVISOR 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FLOOR 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF PLUSP 
; ==>
;   (> NUMBER 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FLOOR 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF MINUSP 
; ==>
;   (< NUMBER 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FTRUNCATE BLOCK 
; --> MACROLET SB-KERNEL::NUMBER-DISPATCH BLOCK TAGBODY RETURN-FROM TYPECASE 
; --> LET COND IF IF PROGN TYPECASE LET COND IF IF PROGN IF 
; --> SB-KERNEL::FTRUNCATE-FLOAT LET* COERCE THE 
; ==>
;   (SB-KERNEL:%SINGLE-FLOAT SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR RATIONAL SINGLE-FLOAT), not a SINGLE-FLOAT.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FTRUNCATE BLOCK 
; --> MACROLET SB-KERNEL::NUMBER-DISPATCH BLOCK TAGBODY RETURN-FROM TYPECASE 
; --> LET COND IF IF IF PROGN TYPECASE LET COND IF PROGN 
; --> SB-KERNEL::FTRUNCATE-FLOAT LET* COERCE THE 
; ==>
;   (SB-KERNEL:%DOUBLE-FLOAT SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a FLOAT, not a DOUBLE-FLOAT.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FTRUNCATE BLOCK 
; --> MACROLET SB-KERNEL::NUMBER-DISPATCH BLOCK TAGBODY RETURN-FROM TYPECASE 
; --> LET COND IF IF PROGN TYPECASE LET COND IF IF PROGN IF 
; --> SB-KERNEL::FTRUNCATE-FLOAT LET* COERCE THE 
; ==>
;   (SB-KERNEL:%SINGLE-FLOAT SB-C::X)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (OR RATIONAL SINGLE-FLOAT), not a (SIGNED-BYTE 64).

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FTRUNCATE BLOCK 
; --> MACROLET SB-KERNEL::NUMBER-DISPATCH BLOCK TAGBODY RETURN-FROM TYPECASE 
; --> LET COND IF IF IF PROGN TYPECASE LET COND IF PROGN 
; --> SB-KERNEL::FTRUNCATE-FLOAT LET* COERCE 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 FLOAT, not a SINGLE-FLOAT.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FTRUNCATE BLOCK 
; --> MACROLET SB-KERNEL::NUMBER-DISPATCH BLOCK TAGBODY RETURN-FROM TYPECASE 
; --> LET COND IF IF IF PROGN TYPECASE LET COND IF IF PROGN IF 
; --> SB-KERNEL::FTRUNCATE-FLOAT LET* COERCE 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 RATIONAL, not a (SIGNED-BYTE 64).

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FTRUNCATE BLOCK 
; --> MACROLET SB-KERNEL::NUMBER-DISPATCH BLOCK TAGBODY RETURN-FROM TYPECASE 
; --> LET COND IF IF IF IF PROGN TYPECASE LET COND IF IF PROGN 
; --> SB-KERNEL::FTRUNCATE-FLOAT LET* SB-KERNEL:%UNARY-FTRUNCATE / / FLOAT 
; ==>
;   (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 BIGNUM, not a (SIGNED-BYTE 64).

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FTRUNCATE BLOCK 
; --> MACROLET SB-KERNEL::NUMBER-DISPATCH BLOCK TAGBODY RETURN-FROM TYPECASE 
; --> LET COND IF IF IF IF PROGN TYPECASE LET COND IF IF PROGN 
; --> SB-KERNEL::FTRUNCATE-FLOAT LET* VALUES - - FLOAT 
; ==>
;   (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 BIGNUM, not a (SIGNED-BYTE 64).

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FTRUNCATE BLOCK 
; --> MACROLET SB-KERNEL::NUMBER-DISPATCH BLOCK TAGBODY RETURN-FROM TYPECASE 
; --> LET COND IF IF IF IF PROGN TYPECASE LET COND IF IF IF PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION VALUES FLOAT 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 INTEGER, not a (SIGNED-BYTE 64).

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FTRUNCATE BLOCK 
; --> MACROLET SB-KERNEL::NUMBER-DISPATCH BLOCK TAGBODY RETURN-FROM TYPECASE 
; --> LET COND IF IF IF IF IF PROGN TYPECASE LET COND IF IF IF PROGN 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION VALUES FLOAT 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 INTEGER, not a (SIGNED-BYTE 64).

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FTRUNCATE BLOCK 
; --> MACROLET SB-KERNEL::NUMBER-DISPATCH BLOCK TAGBODY RETURN-FROM TYPECASE 
; --> LET COND IF PROGN TYPECASE LET COND IF IF IF PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION VALUES FLOAT 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 INTEGER, not a (SIGNED-BYTE 64).

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET LET LET - * - 
; ==>
;   (* CL-VARIATES::K (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::IQ))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a FLOAT, not a SINGLE-FLOAT.
;       The second argument is a 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 4) because:
;       The first argument is a FLOAT, not a SINGLE-FLOAT.
;       The second argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET LET LET - * 
; ==>
;   (- (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::INTERNAL-SEED)
;      (* CL-VARIATES::K (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::IQ)))
; 
; 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.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET LET LET - 
; ==>
;   (* (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::IA)
;      (- (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::INTERNAL-SEED)
;         (* CL-VARIATES::K (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::IQ))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; ==>
;   (* (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::IR) CL-VARIATES::K)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a 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 T, 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.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET LET LET 
; ==>
;   (-
;    (* (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::IA)
;       (- (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::INTERNAL-SEED)
;          (* CL-VARIATES::K
;             (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::IQ))))
;    (* (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::IR) CL-VARIATES::K))
; 
; 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.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET IF 
; ==>
;   (< (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::INTERNAL-SEED) 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.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET IF LET LET 
; ==>
;   (+ (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::INTERNAL-SEED)
;      (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::IM))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FLOOR 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF MINUSP 
; ==>
;   (< SB-C::DIVISOR 0)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

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

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FLOOR 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF PLUSP 
; ==>
;   (> NUMBER 0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FLOOR 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 1- 
; ==>
;   (- SB-C::TRU 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET 
; ==>
;   (* (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::AM)
;      (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::IY))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET IF 
; ==>
;   (> CL-VARIATES::TEMP (SB-PCL::ACCESSOR-SLOT-VALUE #:G0 'CL-VARIATES::RNMX))
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FTRUNCATE BLOCK 
; --> MACROLET SB-KERNEL::NUMBER-DISPATCH BLOCK TAGBODY RETURN-FROM TYPECASE 
; --> LET COND IF PROGN TYPECASE LET COND IF IF PROGN 
; --> SB-KERNEL::FTRUNCATE-FLOAT LET* SB-KERNEL:%UNARY-FTRUNCATE 
; ==>
;   (SB-C::%UNARY-FTRUNCATE/DOUBLE SB-C::X)
; 
; note: doing float to pointer coercion (cost 13)

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FTRUNCATE BLOCK 
; --> MACROLET SB-KERNEL::NUMBER-DISPATCH BLOCK TAGBODY RETURN-FROM TYPECASE 
; --> LET COND IF IF IF IF IF PROGN TYPECASE LET COND IF IF PROGN 
; --> SB-KERNEL::FTRUNCATE-FLOAT LET* SB-KERNEL:%UNARY-FTRUNCATE 
; ==>
;   (SB-C::%UNARY-FTRUNCATE/DOUBLE SB-C::X)
; 
; note: doing float to pointer coercion (cost 13)

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FTRUNCATE BLOCK 
; --> MACROLET SB-KERNEL::NUMBER-DISPATCH BLOCK TAGBODY RETURN-FROM TYPECASE 
; --> LET COND IF IF IF IF PROGN TYPECASE LET COND IF IF PROGN 
; --> SB-KERNEL::FTRUNCATE-FLOAT LET* SB-KERNEL:%UNARY-FTRUNCATE 
; ==>
;   (SB-C::%UNARY-FTRUNCATE/DOUBLE SB-C::X)
; 
; note: doing float to pointer coercion (cost 13)

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FTRUNCATE BLOCK 
; --> MACROLET SB-KERNEL::NUMBER-DISPATCH BLOCK TAGBODY RETURN-FROM TYPECASE 
; --> LET COND IF IF IF PROGN TYPECASE LET COND IF IF PROGN IF 
; --> SB-KERNEL::FTRUNCATE-FLOAT LET* SB-KERNEL:%UNARY-FTRUNCATE 
; ==>
;   (SB-C::%UNARY-FTRUNCATE/DOUBLE SB-C::X)
; 
; note: doing float to pointer coercion (cost 13)

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FTRUNCATE BLOCK 
; --> MACROLET SB-KERNEL::NUMBER-DISPATCH BLOCK TAGBODY RETURN-FROM TYPECASE 
; --> LET COND IF IF IF PROGN TYPECASE LET COND IF PROGN 
; --> SB-KERNEL::FTRUNCATE-FLOAT LET* SB-KERNEL:%UNARY-FTRUNCATE 
; ==>
;   (SB-C::%UNARY-FTRUNCATE/DOUBLE SB-C::X)
; 
; note: doing float to pointer coercion (cost 13)

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET SYMBOL-MACROLET LET FTRUNCATE BLOCK 
; --> MACROLET SB-KERNEL::NUMBER-DISPATCH BLOCK TAGBODY RETURN-FROM TYPECASE 
; --> LET COND IF IF PROGN TYPECASE LET COND IF PROGN 
; --> SB-KERNEL::FTRUNCATE-FLOAT LET* SB-KERNEL:%UNARY-FTRUNCATE 
; ==>
;   (SB-C::%UNARY-FTRUNCATE/DOUBLE SB-C::X)
; 
; note: doing float to pointer coercion (cost 13)
WARNING: redefining CL-VARIATES:RANDOM-SEED in DEFGENERIC
Unhandled SB-EXT:NAME-CONFLICT in thread #<SB-THREAD:THREAD "main thread" RUNNING {10006105B3}>: USE-PACKAGE #<PACKAGE "CL-VARIATES"> causes name-conflicts in #<PACKAGE "METABANG.CL-CONTAINERS"> between the following symbols: CL-VARIATES:NEXT-ELEMENT, METABANG.UTILITIES:NEXT-ELEMENT
See also:
  The ANSI Standard, Section 11.1.1.2.5

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {10006105B3}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<SB-EXT:NAME-CONFLICT {10097EC4B3}> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK SB-EXT:*INVOKE-DEBUGGER-HOOK* #<SB-EXT:NAME-CONFLICT {10097EC4B3}>)
2: (INVOKE-DEBUGGER #<SB-EXT:NAME-CONFLICT {10097EC4B3}>)
3: (ERROR #<SB-EXT:NAME-CONFLICT {10097EC4B3}>)
4: (SB-KERNEL:WITH-SIMPLE-CONDITION-RESTARTS ERROR NIL SB-EXT:NAME-CONFLICT :PACKAGE #<PACKAGE "METABANG.CL-CONTAINERS"> :SYMBOLS (CL-VARIATES:NEXT-ELEMENT NEXT-ELEMENT) :FUNCTION USE-PACKAGE :DATUM #<PACKAGE "CL-VARIATES">)
5: (SB-EXT:NAME-CONFLICT #<PACKAGE "METABANG.CL-CONTAINERS"> USE-PACKAGE #<PACKAGE "CL-VARIATES"> CL-VARIATES:NEXT-ELEMENT NEXT-ELEMENT)
6: ((FLET SB-IMPL::THUNK :IN USE-PACKAGE))
7: ((FLET "WITHOUT-INTERRUPTS-BODY-29" :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
8: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SB-IMPL::CALL-WITH-PACKAGE-GRAPH) {7FFFF6DA5E6B}> #<SB-THREAD:MUTEX "Package Graph Lock" owner: #<SB-THREAD:THREAD "main thread" RUNNING {10006105B3}>> T NIL)
9: (SB-IMPL::CALL-WITH-PACKAGE-GRAPH #<CLOSURE (FLET SB-IMPL::THUNK :IN USE-PACKAGE) {7FFFF6DA5EAB}>)
10: (USE-PACKAGE #<PACKAGE "CL-VARIATES"> #<PACKAGE "METABANG.CL-CONTAINERS">)
11: (SB-INT:SIMPLE-EVAL-IN-LEXENV (USE-PACKAGE (FIND-PACKAGE (QUOTE CL-VARIATES)) (FIND-PACKAGE (QUOTE CL-CONTAINERS))) #<NULL-LEXENV>)
12: (SB-INT:SIMPLE-EVAL-IN-LEXENV (PROGN (USE-PACKAGE (FIND-PACKAGE (QUOTE CL-VARIATES)) (FIND-PACKAGE (QUOTE CL-CONTAINERS)))) #<NULL-LEXENV>)
13: (SB-EXT:EVAL-TLF (PROGN (USE-PACKAGE (FIND-PACKAGE (QUOTE CL-VARIATES)) (FIND-PACKAGE (QUOTE CL-CONTAINERS)))) 1 #<NULL-LEXENV>)
14: ((FLET SB-C::FROB :IN SB-C::EVAL-COMPILE-TOPLEVEL))
15: ((FLET SB-C::DEFAULT-PROCESSOR :IN SB-C::PROCESS-TOPLEVEL-FORM) (USE-PACKAGE (FIND-PACKAGE (QUOTE CL-VARIATES)) (FIND-PACKAGE (QUOTE CL-CONTAINERS))))
16: (SB-C::PROCESS-TOPLEVEL-FORM (USE-PACKAGE (FIND-PACKAGE (QUOTE CL-VARIATES)) (FIND-PACKAGE (QUOTE CL-CONTAINERS))) (SB-C::ORIGINAL-SOURCE-START 0 1) (:COMPILE-TOPLEVEL))
17: (SB-C::PROCESS-TOPLEVEL-PROGN ((USE-PACKAGE (FIND-PACKAGE (QUOTE CL-VARIATES)) (FIND-PACKAGE (QUOTE CL-CONTAINERS)))) (SB-C::ORIGINAL-SOURCE-START 0 1) (:COMPILE-TOPLEVEL))
18: (SB-C::PROCESS-TOPLEVEL-FORM (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (USE-PACKAGE (FIND-PACKAGE (QUOTE CL-VARIATES)) (FIND-PACKAGE (QUOTE CL-CONTAINERS)))) (SB-C::ORIGINAL-SOURCE-START 0 1) NIL)
19: ((LAMBDA (SB-KERNEL:FORM &KEY :CURRENT-INDEX &ALLOW-OTHER-KEYS) :IN SB-C::SUB-SUB-COMPILE-FILE) (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (USE-PACKAGE (FIND-PACKAGE (QUOTE CL-VARIATES)) (FIND-PACKAGE (QUOTE CL-CONTAINERS)))) :CURRENT-INDEX 1)
20: (SB-C::%DO-FORMS-FROM-INFO #<FUNCTION (LAMBDA (SB-KERNEL:FORM &KEY :CURRENT-INDEX &ALLOW-OTHER-KEYS) :IN SB-C::SUB-SUB-COMPILE-FILE) {22248C2B}> #<SB-C::SOURCE-INFO {10097CD833}> SB-C::INPUT-ERROR-IN-COMPILE-FILE)
21: (SB-C::SUB-SUB-COMPILE-FILE #<SB-C::SOURCE-INFO {10097CD833}>)
22: ((FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SB-C::SUB-COMPILE-FILE))
23: ((FLET "WITHOUT-INTERRUPTS-BODY-29" :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
24: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SB-C::SUB-COMPILE-FILE) {7FFFF6DA66DB}> #<SB-THREAD:MUTEX "World Lock" owner: #<SB-THREAD:THREAD "main thread" RUNNING {10006105B3}>> T NIL)
25: ((LAMBDA NIL :IN SB-C::SUB-COMPILE-FILE))
26: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
27: (SB-C::SUB-COMPILE-FILE #<SB-C::SOURCE-INFO {10097CD833}>)
28: (COMPILE-FILE #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-containers/3b0e0761995c807fa27cdc74ef97fecf1ba48339/cl-containers-20180202-git/dev/container-sampling.lisp" :OUTPUT-FILE #P#<(SIMPLE-ARRAY CHARACTER (230)) /home/quicklisp/.cache/common-lisp/sbcl-1.4.4-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/cl-containers/3b0e0761995c807fa27cdc74ef97fecf1ba48339/cl-containers-20180202-git/dev/conta... {100982C6AF}> :VERBOSE NIL :PRINT NIL :EXTERNAL-FORMAT :UTF-8 :TRACE-FILE NIL :BLOCK-COMPILE NIL :EMIT-CFASL NIL)
29: (UIOP/UTILITY:CALL-WITH-MUFFLED-CONDITIONS #<CLOSURE (LAMBDA NIL :IN UIOP/LISP-BUILD:COMPILE-FILE*) {10097CAB6B}> NIL)
30: (UIOP/PATHNAME:CALL-WITH-ENOUGH-PATHNAME #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-containers/3b0e0761995c807fa27cdc74ef97fecf1ba48339/cl-containers-20180202-git/dev/container-sampling.lisp" NIL #<CLOSURE (LAMBDA (UIOP/LISP-BUILD::INPUT-FILE) :IN UIOP/LISP-BUILD:COMPILE-FILE*) {10097CA35B}>)
31: (UIOP/LISP-BUILD:COMPILE-FILE* #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-containers/3b0e0761995c807fa27cdc74ef97fecf1ba48339/cl-containers-20180202-git/dev/container-sampling.lisp" :OUTPUT-FILE #P#<(SIMPLE-ARRAY CHARACTER (218)) /home/quicklisp/.cache/common-lisp/sbcl-1.4.4-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/cl-containers/3b0e0761995c807fa27cdc74ef97fecf1ba48339/cl-containers-20180202-git/dev/conta... {1009838EEF}> :EXTERNAL-FORMAT :UTF-8 :WARNINGS-FILE NIL)
32: (ASDF/LISP-ACTION:PERFORM-LISP-COMPILATION #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "cl-containers/with-variates" "dev" "container-sampling">)
33: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "cl-containers/with-variates" "dev" "container-sampling">)
34: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
35: ((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS :AROUND (T T)) #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "cl-containers/with-variates" "dev" "container-sampling">) [fast-method]
36: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1006332683}>) [fast-method]
37: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
38: ((:METHOD ASDF/PLAN:PERFORM-PLAN :AROUND (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1006332683}>) [fast-method]
39: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/INTERFACE::SYSTEM-CONNECTION "cl-containers/with-variates"> :PLAN-CLASS NIL :PLAN-OPTIONS NIL) [fast-method]
40: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/INTERFACE::SYSTEM-CONNECTION "cl-containers/with-variates">)
41: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
42: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/INTERFACE::SYSTEM-CONNECTION "cl-containers/with-variates">) [fast-method]
43: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "cl-containers/with-variates")
44: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
45: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "cl-containers/with-variates") [fast-method]
46: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {10062D799B}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
47: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
48: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {10062A475B}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
49: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "cl-containers/with-variates") [fast-method]
50: (DEPCHECK::COMPUTE-DEPENDENCIES "cl-containers" "cl-containers/with-variates")
51: (DEPCHECK::MAGIC "cl-containers" "cl-containers/with-variates" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-bHlcl6J7/depcheck-win.txt")
52: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "cl-containers" "cl-containers/with-variates" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-bHlcl6J7/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-bHlcl6J7/depcheck-fail.txt"))
53: ((LAMBDA NIL :IN "/home/quicklisp/src/quicklisp-controller/dumper-2SKVI5f7.lisp"))
54: ((FLET SB-UNIX::BODY :IN SB-EXT:SAVE-LISP-AND-DIE))
55: ((FLET "WITHOUT-INTERRUPTS-BODY-36" :IN SB-EXT:SAVE-LISP-AND-DIE))
56: ((LABELS SB-IMPL::RESTART-LISP :IN SB-EXT:SAVE-LISP-AND-DIE))

unhandled condition in --disable-debugger mode, quitting
; 
; compilation unit aborted
;   caught 2 fatal ERROR conditions
;   printed 41 notes