numcl

SBCL 2.1.6 / ASDF 3.3.5

numcl

WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/symbol-munger/a8589c60f470b8b280eacd9c983d96bc5f337341/symbol-munger-20210721-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-20210721-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 ... {10074DBAFF}>)
; --> 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).
; It allows an unknown number of values, consider using
; (VALUES &OPTIONAL SYMBOL).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/constantfold/378cbed129d745f65125c9f3931f350e92d61c22/constantfold-20210721-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).
; It allows an unknown number of values, consider using
; (VALUES &OPTIONAL SYMBOL).
Unhandled TYPE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING {1001BE8103}>: The value * is not of type LIST

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {1001BE8103}>
0: ((SB-C:DEFTRANSFORM COERCE) #<SB-C::COMBINATION :FUN #<SB-C::REF  :LEAF #<SB-C::GLOBAL-VAR :%SOURCE-NAME COERCE :TYPE #1=#<SB-KERNEL:FUN-TYPE (FUNCTION (T #) (VALUES T &OPTIONAL))> :DEFINED-TYPE #1# :WHERE-FROM :DECLARED :KIND :GLOBAL-FUNCTION {1008939953}> {1008939E33}> :ARGS (#<SB-C::REF :%SOURCE-NAME STATE :LEAF #<SB-C::LAMBDA-VAR :%SOURCE-NAME STATE :ARG-INFO #<SB-C::ARG-INFO  :KIND :OPTIONAL {10089280D3}> {1008928003}> {1008939FF3}> #<SB-C::REF  :LEAF #<SB-KERNEL:CONSTANT :VALUE ARRAY {100893A183}> {100893A273}>) {1008939EC3}>)
1: (SB-C::IR1-OPTIMIZE-COMBINATION #<SB-C::COMBINATION :FUN #<SB-C::REF  :LEAF #<SB-C::GLOBAL-VAR :%SOURCE-NAME COERCE :TYPE #1=#<SB-KERNEL:FUN-TYPE (FUNCTION (T #) (VALUES T &OPTIONAL))> :DEFINED-TYPE #1# :WHERE-FROM :DECLARED :KIND :GLOBAL-FUNCTION {1008939953}> {1008939E33}> :ARGS (#<SB-C::REF :%SOURCE-NAME STATE :LEAF #<SB-C::LAMBDA-VAR :%SOURCE-NAME STATE :ARG-INFO #<SB-C::ARG-INFO  :KIND :OPTIONAL {10089280D3}> {1008928003}> {1008939FF3}> #<SB-C::REF  :LEAF #<SB-KERNEL:CONSTANT :VALUE ARRAY {100893A183}> {100893A273}>) {1008939EC3}>)
2: (SB-C::IR1-OPTIMIZE #<SB-C:COMPONENT :NAME MAKE-MT-RANDOM-STATE :REANALYZE T {1008943453}> NIL)
3: (SB-C::IR1-OPTIMIZE-UNTIL-DONE #<SB-C:COMPONENT :NAME MAKE-MT-RANDOM-STATE :REANALYZE T {1008943453}>)
4: (SB-C::IR1-OPTIMIZE-PHASE-1 #<SB-C:COMPONENT :NAME MAKE-MT-RANDOM-STATE :REANALYZE T {1008943453}>)
5: (SB-C::IR1-PHASES #<SB-C:COMPONENT :NAME MAKE-MT-RANDOM-STATE :REANALYZE T {1008943453}>)
6: (SB-C::COMPILE-COMPONENT #<SB-C:COMPONENT :NAME MAKE-MT-RANDOM-STATE :REANALYZE T {1008943453}>)
7: (SB-C::%COMPILE (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {10089225AF}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND ((EQ STATE T) (MT-MAKE-RANDOM-STATE-RANDOM)) ((NULL STATE) (MAKE-MT-RANDOM-STATE *MT-RANDOM-STATE*)) ((INTEGERP STATE) (MT-MAKE-RANDOM-STATE-INTEGER STATE)) ((TYPEP STATE #) (ASSERT STATE) (ASSERT #) (ASSERT #) (MT-INTERNAL-MAKE-RANDOM-STATE :MTI 0 :ARR #)) ((MT-RANDOM-STATE-P STATE) (MT-INTERNAL-MAKE-RANDOM-STATE :MTI # :ARR #)) (T (CERROR "STATE should not have a value of ~A" STATE))))) #<SB-FASL:FASL-OUTPUT #<(SIMPLE-BASE-STRING 205) /home/quicklisp/.cache/common-lisp/sbcl-2.1.6-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/2ac16dba12675732dc07abdc0451fcc78cc333b3/cl-randist-20210721-git/jmt-tmp5GEXGEG5... {100897F3CF}>> :NAME NIL :PATH ((FUNCTION #1=(SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {10089225AF}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND # # # # # #)))) #1# #2=(SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) #1#) #2# (PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL) (SB-C:%COMPILER-DEFUN (QUOTE MAKE-MT-RANDOM-STATE) T NIL NIL)) #2#) SB-C::ORIGINAL-SOURCE-START 0 12))
8: (SB-C::FOPCOMPILE-FUNCTION #<SB-FASL:FASL-OUTPUT #<(SIMPLE-BASE-STRING 205) /home/quicklisp/.cache/common-lisp/sbcl-2.1.6-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/2ac16dba12675732dc07abdc0451fcc78cc333b3/cl-randist-20210721-git/jmt-tmp5GEXGEG5... {100897F3CF}>> (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {10089225AF}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND ((EQ STATE T) (MT-MAKE-RANDOM-STATE-RANDOM)) ((NULL STATE) (MAKE-MT-RANDOM-STATE *MT-RANDOM-STATE*)) ((INTEGERP STATE) (MT-MAKE-RANDOM-STATE-INTEGER STATE)) ((TYPEP STATE #) (ASSERT STATE) (ASSERT #) (ASSERT #) (MT-INTERNAL-MAKE-RANDOM-STATE :MTI 0 :ARR #)) ((MT-RANDOM-STATE-P STATE) (MT-INTERNAL-MAKE-RANDOM-STATE :MTI # :ARR #)) (T (CERROR "STATE should not have a value of ~A" STATE))))) ((FUNCTION #1=(SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {10089225AF}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND # # # # # #)))) #1# #2=(SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) #1#) #2# (PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL) (SB-C:%COMPILER-DEFUN (QUOTE MAKE-MT-RANDOM-STATE) T NIL NIL)) #2#) SB-C::ORIGINAL-SOURCE-START 0 12) T)
9: (SB-C::FOPCOMPILE (SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {10089225AF}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND (# #) (# #) (# #) (# # # # #) (# #) (T #))))) (#1=(SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {10089225AF}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND # # # # # #)))) (PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL) (SB-C:%COMPILER-DEFUN (QUOTE MAKE-MT-RANDOM-STATE) T NIL NIL)) #1#) SB-C::ORIGINAL-SOURCE-START 0 12) NIL T)
10: (SB-C::CONVERT-AND-MAYBE-COMPILE (SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {10089225AF}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND (# #) (# #) (# #) (# # # # #) (# #) (T #))))) (#1=(SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {10089225AF}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND # # # # # #)))) (PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL) (SB-C:%COMPILER-DEFUN (QUOTE MAKE-MT-RANDOM-STATE) T NIL NIL)) #1#) SB-C::ORIGINAL-SOURCE-START 0 12) T)
11: (SB-C::PROCESS-TOPLEVEL-FORM (SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {10089225AF}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND (# #) (# #) (# #) (# # # # #) (# #) (T #))))) ((PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL) (SB-C:%COMPILER-DEFUN (QUOTE MAKE-MT-RANDOM-STATE) T NIL NIL)) (SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE #) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {10089225AF}> (DECLARE #) (BLOCK MAKE-MT-RANDOM-STATE #)))) SB-C::ORIGINAL-SOURCE-START 0 12) NIL)
12: (SB-C::PROCESS-TOPLEVEL-PROGN ((EVAL-WHEN (:COMPILE-TOPLEVEL) (SB-C:%COMPILER-DEFUN (QUOTE MAKE-MT-RANDOM-STATE) T NIL NIL)) (SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {10089225AF}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND # # # # # #))))) ((PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL) (SB-C:%COMPILER-DEFUN (QUOTE MAKE-MT-RANDOM-STATE) T NIL NIL)) (SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE #) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {10089225AF}> (DECLARE #) (BLOCK MAKE-MT-RANDOM-STATE #)))) SB-C::ORIGINAL-SOURCE-START 0 12) NIL)
13: (SB-C::PROCESS-TOPLEVEL-FORM (PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL) (SB-C:%COMPILER-DEFUN (QUOTE MAKE-MT-RANDOM-STATE) T NIL NIL)) (SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {10089225AF}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND # # # # # #))))) (SB-C::ORIGINAL-SOURCE-START 0 12) NIL)
14: (SB-C::PROCESS-TOPLEVEL-FORM (DEFUN MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {10089225AF}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (COND ((EQ STATE T) (MT-MAKE-RANDOM-STATE-RANDOM)) ((NULL STATE) (MAKE-MT-RANDOM-STATE *MT-RANDOM-STATE*)) ((INTEGERP STATE) (MT-MAKE-RANDOM-STATE-INTEGER STATE)) ((TYPEP STATE (QUOTE SEQUENCE)) (ASSERT STATE) (ASSERT (EQL # +MT-N+)) (ASSERT (NOT #)) (MT-INTERNAL-MAKE-RANDOM-STATE :MTI 0 :ARR (COPY-SEQ #))) ((MT-RANDOM-STATE-P STATE) (MT-INTERNAL-MAKE-RANDOM-STATE :MTI (MT-RANDOM-STATE-MTI STATE) :ARR (COPY-SEQ #))) (T (CERROR "STATE should not have a value of ~A" STATE)))) (SB-C::ORIGINAL-SOURCE-START 0 12) NIL)
15: ((LAMBDA (SB-KERNEL:FORM &KEY :CURRENT-INDEX &ALLOW-OTHER-KEYS) :IN SB-C::SUB-COMPILE-FILE) (DEFUN MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {10089225AF}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (COND ((EQ STATE T) (MT-MAKE-RANDOM-STATE-RANDOM)) ((NULL STATE) (MAKE-MT-RANDOM-STATE *MT-RANDOM-STATE*)) ((INTEGERP STATE) (MT-MAKE-RANDOM-STATE-INTEGER STATE)) ((TYPEP STATE (QUOTE SEQUENCE)) (ASSERT STATE) (ASSERT (EQL # +MT-N+)) (ASSERT (NOT #)) (MT-INTERNAL-MAKE-RANDOM-STATE :MTI 0 :ARR (COPY-SEQ #))) ((MT-RANDOM-STATE-P STATE) (MT-INTERNAL-MAKE-RANDOM-STATE :MTI (MT-RANDOM-STATE-MTI STATE) :ARR (COPY-SEQ #))) (T (CERROR "STATE should not have a value of ~A" STATE)))) :CURRENT-INDEX 12)
16: (SB-C::%DO-FORMS-FROM-INFO #<FUNCTION (LAMBDA (SB-KERNEL:FORM &KEY :CURRENT-INDEX &ALLOW-OTHER-KEYS) :IN SB-C::SUB-COMPILE-FILE) {52CB174B}> #<SB-C::SOURCE-INFO {100846DF33}> SB-C::INPUT-ERROR-IN-COMPILE-FILE)
17: ((FLET "LAMBDA0" :IN "SYS:SRC;COMPILER;MAIN.LISP"))
18: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
19: (SB-C::SUB-COMPILE-FILE #<SB-C::SOURCE-INFO {100846DF33}> NIL)
20: (COMPILE-FILE #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/2ac16dba12675732dc07abdc0451fcc78cc333b3/cl-randist-20210721-git/jmt.lisp" :OUTPUT-FILE #P#<(SIMPLE-ARRAY CHARACTER (205)) /home/quicklisp/.cache/common-lisp/sbcl-2.1.6-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/2ac16dba12675732dc07abdc0451fcc78cc333b3/cl-randist-20210721-git/jmt-tmp5GEXGEG5... {10089E841F}> :VERBOSE NIL :PRINT NIL :PROGRESS NIL :EXTERNAL-FORMAT :UTF-8 :TRACE-FILE NIL :BLOCK-COMPILE NIL :ENTRY-POINTS NIL :EMIT-CFASL NIL)
21: (UIOP/UTILITY:CALL-WITH-MUFFLED-CONDITIONS #<FUNCTION (LAMBDA NIL :IN UIOP/LISP-BUILD:COMPILE-FILE*) {100846CC6B}> NIL)
22: (UIOP/PATHNAME:CALL-WITH-ENOUGH-PATHNAME #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/2ac16dba12675732dc07abdc0451fcc78cc333b3/cl-randist-20210721-git/jmt.lisp" NIL #<FUNCTION (LAMBDA (UIOP/LISP-BUILD::INPUT-FILE) :IN UIOP/LISP-BUILD:COMPILE-FILE*) {100846C56B}>)
23: (UIOP/LISP-BUILD:COMPILE-FILE* #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/2ac16dba12675732dc07abdc0451fcc78cc333b3/cl-randist-20210721-git/jmt.lisp" :OUTPUT-FILE #P"/home/quicklisp/.cache/common-lisp/sbcl-2.1.6-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/2ac16dba12675732dc07abdc0451fcc78cc333b3/cl-randist-20210721-git/jmt.fasl" :EXTERNAL-FORMAT :UTF-8 :WARNINGS-FILE NIL)
24: (ASDF/LISP-ACTION:PERFORM-LISP-COMPILATION #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "cl-randist" "jmt">)
25: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "cl-randist" "jmt">)
26: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
27: ((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS :AROUND (T T)) #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "cl-randist" "jmt">) [fast-method]
28: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1005698AC3}>) [fast-method]
29: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
30: ((:METHOD ASDF/PLAN:PERFORM-PLAN :AROUND (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1005698AC3}>) [fast-method]
31: ((: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]
32: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "numcl">)
33: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
34: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "numcl">) [fast-method]
35: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "numcl")
36: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
37: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "numcl") [fast-method]
38: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {100569200B}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
39: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
40: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {100565492B}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
41: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "numcl") [fast-method]
42: (DEPCHECK::COMPUTE-DEPENDENCIES "numcl" "numcl")
43: (DEPCHECK::MAGIC "numcl" "numcl" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-Y27pShmP/depcheck-win.txt")
44: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "numcl" "numcl" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-Y27pShmP/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-Y27pShmP/depcheck-fail.txt"))
45: ((LAMBDA NIL :IN "/home/quicklisp/quicklisp/local-projects/quicklisp-controller/dumper-2SKVI5f7.lisp"))
46: ((FLET SB-UNIX::BODY :IN SB-IMPL::START-LISP))
47: ((FLET "WITHOUT-INTERRUPTS-BODY-1" :IN SB-IMPL::START-LISP))
48: (SB-IMPL::START-LISP)

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

numcl.test

WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/symbol-munger/a8589c60f470b8b280eacd9c983d96bc5f337341/symbol-munger-20210721-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.
Unhandled TYPE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING {1001BE8103}>: The value * is not of type LIST

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {1001BE8103}>
0: ((SB-C:DEFTRANSFORM COERCE) #<SB-C::COMBINATION :FUN #<SB-C::REF  :LEAF #<SB-C::GLOBAL-VAR :%SOURCE-NAME COERCE :TYPE #1=#<SB-KERNEL:FUN-TYPE (FUNCTION (T #) (VALUES T &OPTIONAL))> :DEFINED-TYPE #1# :WHERE-FROM :DECLARED :KIND :GLOBAL-FUNCTION {1007A7EBC3}> {1007A7F0A3}> :ARGS (#<SB-C::REF :%SOURCE-NAME STATE :LEAF #<SB-C::LAMBDA-VAR :%SOURCE-NAME STATE :ARG-INFO #<SB-C::ARG-INFO  :KIND :OPTIONAL {1007A6BF53}> {1007A6BE83}> {1007A7F263}> #<SB-C::REF  :LEAF #<SB-KERNEL:CONSTANT :VALUE ARRAY {1007A7F3F3}> {1007A7F4E3}>) {1007A7F133}>)
1: (SB-C::IR1-OPTIMIZE-COMBINATION #<SB-C::COMBINATION :FUN #<SB-C::REF  :LEAF #<SB-C::GLOBAL-VAR :%SOURCE-NAME COERCE :TYPE #1=#<SB-KERNEL:FUN-TYPE (FUNCTION (T #) (VALUES T &OPTIONAL))> :DEFINED-TYPE #1# :WHERE-FROM :DECLARED :KIND :GLOBAL-FUNCTION {1007A7EBC3}> {1007A7F0A3}> :ARGS (#<SB-C::REF :%SOURCE-NAME STATE :LEAF #<SB-C::LAMBDA-VAR :%SOURCE-NAME STATE :ARG-INFO #<SB-C::ARG-INFO  :KIND :OPTIONAL {1007A6BF53}> {1007A6BE83}> {1007A7F263}> #<SB-C::REF  :LEAF #<SB-KERNEL:CONSTANT :VALUE ARRAY {1007A7F3F3}> {1007A7F4E3}>) {1007A7F133}>)
2: (SB-C::IR1-OPTIMIZE #<SB-C:COMPONENT :NAME MAKE-MT-RANDOM-STATE :REANALYZE T {1007A88493}> NIL)
3: (SB-C::IR1-OPTIMIZE-UNTIL-DONE #<SB-C:COMPONENT :NAME MAKE-MT-RANDOM-STATE :REANALYZE T {1007A88493}>)
4: (SB-C::IR1-OPTIMIZE-PHASE-1 #<SB-C:COMPONENT :NAME MAKE-MT-RANDOM-STATE :REANALYZE T {1007A88493}>)
5: (SB-C::IR1-PHASES #<SB-C:COMPONENT :NAME MAKE-MT-RANDOM-STATE :REANALYZE T {1007A88493}>)
6: (SB-C::COMPILE-COMPONENT #<SB-C:COMPONENT :NAME MAKE-MT-RANDOM-STATE :REANALYZE T {1007A88493}>)
7: (SB-C::%COMPILE (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {1007A6644F}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND ((EQ STATE T) (MT-MAKE-RANDOM-STATE-RANDOM)) ((NULL STATE) (MAKE-MT-RANDOM-STATE *MT-RANDOM-STATE*)) ((INTEGERP STATE) (MT-MAKE-RANDOM-STATE-INTEGER STATE)) ((TYPEP STATE #) (ASSERT STATE) (ASSERT #) (ASSERT #) (MT-INTERNAL-MAKE-RANDOM-STATE :MTI 0 :ARR #)) ((MT-RANDOM-STATE-P STATE) (MT-INTERNAL-MAKE-RANDOM-STATE :MTI # :ARR #)) (T (CERROR "STATE should not have a value of ~A" STATE))))) #<SB-FASL:FASL-OUTPUT #<(SIMPLE-BASE-STRING 205) /home/quicklisp/.cache/common-lisp/sbcl-2.1.6-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/2ac16dba12675732dc07abdc0451fcc78cc333b3/cl-randist-20210721-git/jmt-tmpGHU3ALSV... {1007AC486F}>> :NAME NIL :PATH ((FUNCTION #1=(SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {1007A6644F}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND # # # # # #)))) #1# #2=(SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) #1#) #2# (PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL) (SB-C:%COMPILER-DEFUN (QUOTE MAKE-MT-RANDOM-STATE) T NIL NIL)) #2#) SB-C::ORIGINAL-SOURCE-START 0 12))
8: (SB-C::FOPCOMPILE-FUNCTION #<SB-FASL:FASL-OUTPUT #<(SIMPLE-BASE-STRING 205) /home/quicklisp/.cache/common-lisp/sbcl-2.1.6-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/2ac16dba12675732dc07abdc0451fcc78cc333b3/cl-randist-20210721-git/jmt-tmpGHU3ALSV... {1007AC486F}>> (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {1007A6644F}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND ((EQ STATE T) (MT-MAKE-RANDOM-STATE-RANDOM)) ((NULL STATE) (MAKE-MT-RANDOM-STATE *MT-RANDOM-STATE*)) ((INTEGERP STATE) (MT-MAKE-RANDOM-STATE-INTEGER STATE)) ((TYPEP STATE #) (ASSERT STATE) (ASSERT #) (ASSERT #) (MT-INTERNAL-MAKE-RANDOM-STATE :MTI 0 :ARR #)) ((MT-RANDOM-STATE-P STATE) (MT-INTERNAL-MAKE-RANDOM-STATE :MTI # :ARR #)) (T (CERROR "STATE should not have a value of ~A" STATE))))) ((FUNCTION #1=(SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {1007A6644F}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND # # # # # #)))) #1# #2=(SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) #1#) #2# (PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL) (SB-C:%COMPILER-DEFUN (QUOTE MAKE-MT-RANDOM-STATE) T NIL NIL)) #2#) SB-C::ORIGINAL-SOURCE-START 0 12) T)
9: (SB-C::FOPCOMPILE (SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {1007A6644F}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND (# #) (# #) (# #) (# # # # #) (# #) (T #))))) (#1=(SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {1007A6644F}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND # # # # # #)))) (PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL) (SB-C:%COMPILER-DEFUN (QUOTE MAKE-MT-RANDOM-STATE) T NIL NIL)) #1#) SB-C::ORIGINAL-SOURCE-START 0 12) NIL T)
10: (SB-C::CONVERT-AND-MAYBE-COMPILE (SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {1007A6644F}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND (# #) (# #) (# #) (# # # # #) (# #) (T #))))) (#1=(SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {1007A6644F}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND # # # # # #)))) (PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL) (SB-C:%COMPILER-DEFUN (QUOTE MAKE-MT-RANDOM-STATE) T NIL NIL)) #1#) SB-C::ORIGINAL-SOURCE-START 0 12) T)
11: (SB-C::PROCESS-TOPLEVEL-FORM (SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {1007A6644F}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND (# #) (# #) (# #) (# # # # #) (# #) (T #))))) ((PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL) (SB-C:%COMPILER-DEFUN (QUOTE MAKE-MT-RANDOM-STATE) T NIL NIL)) (SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE #) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {1007A6644F}> (DECLARE #) (BLOCK MAKE-MT-RANDOM-STATE #)))) SB-C::ORIGINAL-SOURCE-START 0 12) NIL)
12: (SB-C::PROCESS-TOPLEVEL-PROGN ((EVAL-WHEN (:COMPILE-TOPLEVEL) (SB-C:%COMPILER-DEFUN (QUOTE MAKE-MT-RANDOM-STATE) T NIL NIL)) (SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {1007A6644F}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND # # # # # #))))) ((PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL) (SB-C:%COMPILER-DEFUN (QUOTE MAKE-MT-RANDOM-STATE) T NIL NIL)) (SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE #) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {1007A6644F}> (DECLARE #) (BLOCK MAKE-MT-RANDOM-STATE #)))) SB-C::ORIGINAL-SOURCE-START 0 12) NIL)
13: (SB-C::PROCESS-TOPLEVEL-FORM (PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL) (SB-C:%COMPILER-DEFUN (QUOTE MAKE-MT-RANDOM-STATE) T NIL NIL)) (SB-IMPL::%DEFUN (QUOTE MAKE-MT-RANDOM-STATE) (SB-INT:NAMED-LAMBDA MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) (DECLARE (SB-C::TOP-LEVEL-FORM)) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {1007A6644F}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (BLOCK MAKE-MT-RANDOM-STATE (COND # # # # # #))))) (SB-C::ORIGINAL-SOURCE-START 0 12) NIL)
14: (SB-C::PROCESS-TOPLEVEL-FORM (DEFUN MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {1007A6644F}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (COND ((EQ STATE T) (MT-MAKE-RANDOM-STATE-RANDOM)) ((NULL STATE) (MAKE-MT-RANDOM-STATE *MT-RANDOM-STATE*)) ((INTEGERP STATE) (MT-MAKE-RANDOM-STATE-INTEGER STATE)) ((TYPEP STATE (QUOTE SEQUENCE)) (ASSERT STATE) (ASSERT (EQL # +MT-N+)) (ASSERT (NOT #)) (MT-INTERNAL-MAKE-RANDOM-STATE :MTI 0 :ARR (COPY-SEQ #))) ((MT-RANDOM-STATE-P STATE) (MT-INTERNAL-MAKE-RANDOM-STATE :MTI (MT-RANDOM-STATE-MTI STATE) :ARR (COPY-SEQ #))) (T (CERROR "STATE should not have a value of ~A" STATE)))) (SB-C::ORIGINAL-SOURCE-START 0 12) NIL)
15: ((LAMBDA (SB-KERNEL:FORM &KEY :CURRENT-INDEX &ALLOW-OTHER-KEYS) :IN SB-C::SUB-COMPILE-FILE) (DEFUN MAKE-MT-RANDOM-STATE (&OPTIONAL STATE) #<(SIMPLE-ARRAY CHARACTER (773)) Analogous to Common Lisp's MAKE-RANDOM-STATE except that this function
works on random states for JMT's Mersenne Twister implementation.

Optional state argument is interpreted as follows:
if T -- mak... {1007A6644F}> (DECLARE (SPECIAL *MT-RANDOM-STATE*)) (COND ((EQ STATE T) (MT-MAKE-RANDOM-STATE-RANDOM)) ((NULL STATE) (MAKE-MT-RANDOM-STATE *MT-RANDOM-STATE*)) ((INTEGERP STATE) (MT-MAKE-RANDOM-STATE-INTEGER STATE)) ((TYPEP STATE (QUOTE SEQUENCE)) (ASSERT STATE) (ASSERT (EQL # +MT-N+)) (ASSERT (NOT #)) (MT-INTERNAL-MAKE-RANDOM-STATE :MTI 0 :ARR (COPY-SEQ #))) ((MT-RANDOM-STATE-P STATE) (MT-INTERNAL-MAKE-RANDOM-STATE :MTI (MT-RANDOM-STATE-MTI STATE) :ARR (COPY-SEQ #))) (T (CERROR "STATE should not have a value of ~A" STATE)))) :CURRENT-INDEX 12)
16: (SB-C::%DO-FORMS-FROM-INFO #<FUNCTION (LAMBDA (SB-KERNEL:FORM &KEY :CURRENT-INDEX &ALLOW-OTHER-KEYS) :IN SB-C::SUB-COMPILE-FILE) {52CB174B}> #<SB-C::SOURCE-INFO {100758D503}> SB-C::INPUT-ERROR-IN-COMPILE-FILE)
17: ((FLET "LAMBDA0" :IN "SYS:SRC;COMPILER;MAIN.LISP"))
18: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
19: (SB-C::SUB-COMPILE-FILE #<SB-C::SOURCE-INFO {100758D503}> NIL)
20: (COMPILE-FILE #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/2ac16dba12675732dc07abdc0451fcc78cc333b3/cl-randist-20210721-git/jmt.lisp" :OUTPUT-FILE #P#<(SIMPLE-ARRAY CHARACTER (205)) /home/quicklisp/.cache/common-lisp/sbcl-2.1.6-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/2ac16dba12675732dc07abdc0451fcc78cc333b3/cl-randist-20210721-git/jmt-tmpGHU3ALSV... {1007B2D47F}> :VERBOSE NIL :PRINT NIL :PROGRESS NIL :EXTERNAL-FORMAT :UTF-8 :TRACE-FILE NIL :BLOCK-COMPILE NIL :ENTRY-POINTS NIL :EMIT-CFASL NIL)
21: (UIOP/UTILITY:CALL-WITH-MUFFLED-CONDITIONS #<FUNCTION (LAMBDA NIL :IN UIOP/LISP-BUILD:COMPILE-FILE*) {100758C23B}> NIL)
22: (UIOP/PATHNAME:CALL-WITH-ENOUGH-PATHNAME #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/2ac16dba12675732dc07abdc0451fcc78cc333b3/cl-randist-20210721-git/jmt.lisp" NIL #<FUNCTION (LAMBDA (UIOP/LISP-BUILD::INPUT-FILE) :IN UIOP/LISP-BUILD:COMPILE-FILE*) {100758C1BB}>)
23: (UIOP/LISP-BUILD:COMPILE-FILE* #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/2ac16dba12675732dc07abdc0451fcc78cc333b3/cl-randist-20210721-git/jmt.lisp" :OUTPUT-FILE #P"/home/quicklisp/.cache/common-lisp/sbcl-2.1.6-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/2ac16dba12675732dc07abdc0451fcc78cc333b3/cl-randist-20210721-git/jmt.fasl" :EXTERNAL-FORMAT :UTF-8 :WARNINGS-FILE NIL)
24: (ASDF/LISP-ACTION:PERFORM-LISP-COMPILATION #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "cl-randist" "jmt">)
25: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "cl-randist" "jmt">)
26: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
27: ((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS :AROUND (T T)) #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "cl-randist" "jmt">) [fast-method]
28: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1005706BF3}>) [fast-method]
29: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
30: ((:METHOD ASDF/PLAN:PERFORM-PLAN :AROUND (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1005706BF3}>) [fast-method]
31: ((: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]
32: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "numcl.test">)
33: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
34: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "numcl.test">) [fast-method]
35: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "numcl.test")
36: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
37: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "numcl.test") [fast-method]
38: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {100570009B}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
39: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
40: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {10056C293B}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
41: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "numcl.test") [fast-method]
42: (DEPCHECK::COMPUTE-DEPENDENCIES "numcl.test" "numcl.test")
43: (DEPCHECK::MAGIC "numcl.test" "numcl.test" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-rrbhSncz/depcheck-win.txt")
44: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "numcl.test" "numcl.test" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-rrbhSncz/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-rrbhSncz/depcheck-fail.txt"))
45: ((LAMBDA NIL :IN "/home/quicklisp/quicklisp/local-projects/quicklisp-controller/dumper-2SKVI5f7.lisp"))
46: ((FLET SB-UNIX::BODY :IN SB-IMPL::START-LISP))
47: ((FLET "WITHOUT-INTERRUPTS-BODY-1" :IN SB-IMPL::START-LISP))
48: (SB-IMPL::START-LISP)

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