cl-conllu

SBCL 1.4.5.211-da163c7 / ASDF 3.3.1

cl-conllu

WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-ppcre/3d57f1e446e4894097acebf36d52978ddaa62531/cl-ppcre-20180414-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/trivial-utf-8/a6eb987246e5f233c6b9c4b8b15edbbe2770d848/trivial-utf-8-20180414-git/trivial-utf-8.asd" contains definition for system "trivial-utf-8-tests". Please only define "trivial-utf-8" and secondary systems with a name starting with "trivial-utf-8/" (e.g. "trivial-utf-8/test") in that file.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/optimize.lisp
; in: DEFUN SELECT-GREEDY-KLEENE-INSTR
;     (AND (NOT LISPBUILDER-REGEX::NULLPAT) LISPBUILDER-REGEX::LOOPPAT)
; --> IF 
; ==>
;   LISPBUILDER-REGEX::LOOPPAT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/optimize.lisp
; in: DEFUN SELECT-NONGREEDY-KLEENE-INSTR
;     (AND (NOT LISPBUILDER-REGEX::NULLPAT) LISPBUILDER-REGEX::LOOPPAT)
; --> IF 
; ==>
;   LISPBUILDER-REGEX::LOOPPAT
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-CHAR-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::POS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FUNCALL LISPBUILDER-REGEX::NEXT (1+ LISPBUILDER-REGEX::POS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-STRING-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::I)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::PATSTR LISPBUILDER-REGEX::J)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-CLASSSEQ-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::I)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FIND
;      (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::I)
;      (SVREF LISPBUILDER-REGEX::CHRCLASSES LISPBUILDER-REGEX::J))
; 
; note: unable to optimize due to type uncertainty: The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

;     (FUNCALL LISPBUILDER-REGEX::NEXT LISPBUILDER-REGEX::REG-STR-END)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function

;     (FIND
;      (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::I)
;      (SVREF LISPBUILDER-REGEX::CHRCLASSES LISPBUILDER-REGEX::J))
; 
; note: unable to optimize due to type uncertainty: The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

;     (FUNCALL LISPBUILDER-REGEX::NEXT LISPBUILDER-REGEX::REG-STR-END)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-BACKMATCH-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::I)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::J)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

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

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

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

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

;     (- LISPBUILDER-REGEX::REG-END LISPBUILDER-REGEX::REG-START)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-STR-GREEDY-KLEENE-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::I)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::PATSTR LISPBUILDER-REGEX::J)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-CHAR-GREEDY-KLEENE-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;      LISPBUILDER-REGEX::NEWPOS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-NOT-CHAR-GREEDY-KLEENE-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;      LISPBUILDER-REGEX::NEWPOS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-CCLASS-2-GREEDY-KLEENE-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;      LISPBUILDER-REGEX::NEWPOS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-NOT-CCLASS-2-GREEDY-KLEENE-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;      LISPBUILDER-REGEX::NEWPOS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-CCLASS-GREEDY-KLEENE-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;      LISPBUILDER-REGEX::NEWPOS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-NOT-CCLASS-GREEDY-KLEENE-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;      LISPBUILDER-REGEX::NEWPOS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-SPECCLASS-GREEDY-KLEENE-CLOSURE
;     (FUNCALL LISPBUILDER-REGEX::CLASSFN
;              (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;               LISPBUILDER-REGEX::NEWPOS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::CLASSFN)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: CLASSFN is not known to be a function

;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;      LISPBUILDER-REGEX::NEWPOS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

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

;     (FUNCALL LISPBUILDER-REGEX::CLASSFN
;              (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;               LISPBUILDER-REGEX::NEWPOS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::CLASSFN)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: CLASSFN is not known to be a function

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-NOT-SPECCLASS-GREEDY-KLEENE-CLOSURE
;     (FUNCALL LISPBUILDER-REGEX::CLASSFN
;              (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;               LISPBUILDER-REGEX::NEWPOS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::CLASSFN)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: CLASSFN is not known to be a function

;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;      LISPBUILDER-REGEX::NEWPOS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

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

;     (FUNCALL LISPBUILDER-REGEX::CLASSFN
;              (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;               LISPBUILDER-REGEX::NEWPOS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::CLASSFN)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: CLASSFN is not known to be a function

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-ALT-2-SIMPLE-TERMCHECK-1-CLOSURE
;     (FUNCALL LISPBUILDER-REGEX::NEXT1 LISPBUILDER-REGEX::POS)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT1)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT1 is not known to be a function

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-ALT-2-SIMPLE-TERMCHECK-2-CLOSURE
;     (FUNCALL LISPBUILDER-REGEX::NEXT1 LISPBUILDER-REGEX::POS)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT1)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT1 is not known to be a function

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-ALT-2-FULL-TERMCHECK-CLOSURE
;     (FUNCALL LISPBUILDER-REGEX::NEXT1 LISPBUILDER-REGEX::POS)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT1)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT1 is not known to be a function

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

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

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-ALT-2-NO-TERMCHECK-CLOSURE
;     (FUNCALL LISPBUILDER-REGEX::NEXT1 LISPBUILDER-REGEX::POS)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT1)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT1 is not known to be a function

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-ALT-NO-TERMCHECK-CLOSURE
;     (FUNCALL (SVREF LISPBUILDER-REGEX::NEXTS LISPBUILDER-REGEX::I)
;              LISPBUILDER-REGEX::POS)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL
;    (SVREF LISPBUILDER-REGEX::NEXTS LISPBUILDER-REGEX::I))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-CASEALT-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::POS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (* 2 LISPBUILDER-REGEX::NUM-JUMP-ENTRIES)
; 
; 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.

;     (FUNCALL
;      (SVREF LISPBUILDER-REGEX::JMPTBL (1+ LISPBUILDER-REGEX::DISCRIMINATOR-IDX))
;      LISPBUILDER-REGEX::POS)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL
;    (SVREF LISPBUILDER-REGEX::JMPTBL (1+ LISPBUILDER-REGEX::DISCRIMINATOR-IDX)))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

;     (* 2 LISPBUILDER-REGEX::NUM-JUMP-ENTRIES)
; 
; 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.

;     (FUNCALL
;      (SVREF LISPBUILDER-REGEX::JMPTBL (1+ LISPBUILDER-REGEX::DISCRIMINATOR-IDX))
;      LISPBUILDER-REGEX::POS)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL
;    (SVREF LISPBUILDER-REGEX::JMPTBL (1+ LISPBUILDER-REGEX::DISCRIMINATOR-IDX)))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

;     (* 2 LISPBUILDER-REGEX::NUM-JUMP-ENTRIES)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 3) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-STARTANCHOR-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;      (1- LISPBUILDER-REGEX::POS))
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-ENDANCHOR-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::POS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-LEFT-RSTART-CLOSURE
;     (FUNCALL LISPBUILDER-REGEX::NEXT LISPBUILDER-REGEX::POS)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-RIGHT-RSTART-CLOSURE
;     (FUNCALL LISPBUILDER-REGEX::NEXT LISPBUILDER-REGEX::POS)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-REND-CLOSURE
;     (FUNCALL LISPBUILDER-REGEX::NEXT LISPBUILDER-REGEX::POS)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-CCLASS-2-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::POS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FUNCALL LISPBUILDER-REGEX::NEXT (1+ LISPBUILDER-REGEX::POS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-CCLASS-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::POS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FUNCALL LISPBUILDER-REGEX::NEXT (1+ LISPBUILDER-REGEX::POS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-NOT-CHAR-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::POS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FUNCALL LISPBUILDER-REGEX::NEXT (1+ LISPBUILDER-REGEX::POS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-NOT-CCLASS-2-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::POS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FUNCALL LISPBUILDER-REGEX::NEXT (1+ LISPBUILDER-REGEX::POS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-NOT-CCLASS-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::POS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FUNCALL LISPBUILDER-REGEX::NEXT (1+ LISPBUILDER-REGEX::POS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-SPECCLASS-CLOSURE
;     (FUNCALL LISPBUILDER-REGEX::CLASSFN
;              (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;               LISPBUILDER-REGEX::POS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::CLASSFN)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: CLASSFN is not known to be a function

;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::POS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FUNCALL LISPBUILDER-REGEX::NEXT (1+ LISPBUILDER-REGEX::POS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function

;     (FUNCALL LISPBUILDER-REGEX::CLASSFN
;              (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;               LISPBUILDER-REGEX::POS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::CLASSFN)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: CLASSFN is not known to be a function

;     (FUNCALL LISPBUILDER-REGEX::NEXT (1+ LISPBUILDER-REGEX::POS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-NOT-SPECCLASS-CLOSURE
;     (FUNCALL LISPBUILDER-REGEX::CLASSFN
;              (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;               LISPBUILDER-REGEX::POS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::CLASSFN)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: CLASSFN is not known to be a function

;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::POS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FUNCALL LISPBUILDER-REGEX::NEXT (1+ LISPBUILDER-REGEX::POS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function

;     (FUNCALL LISPBUILDER-REGEX::CLASSFN
;              (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;               LISPBUILDER-REGEX::POS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::CLASSFN)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: CLASSFN is not known to be a function

;     (FUNCALL LISPBUILDER-REGEX::NEXT (1+ LISPBUILDER-REGEX::POS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-ANY-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::POS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FUNCALL LISPBUILDER-REGEX::NEXT (1+ LISPBUILDER-REGEX::POS))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-STARTWORD-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;      (1- LISPBUILDER-REGEX::POS))
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::POS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-ENDWORD-CLOSURE
;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR*
;      (1- LISPBUILDER-REGEX::POS))
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (LISPBUILDER-REGEX::RE-CHAR LISPBUILDER-REGEX::*STR* LISPBUILDER-REGEX::POS)
; --> THE CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN GEN-SUCCESS-CLOSURE
;     (FUNCALL LISPBUILDER-REGEX::*ACCEPTFN* LISPBUILDER-REGEX::MATCH-START
;              LISPBUILDER-REGEX::MATCH-END)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::*ACCEPTFN*)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

;     (VALUES LISPBUILDER-REGEX::RC LISPBUILDER-REGEX::MATCH-START
;             (- LISPBUILDER-REGEX::MATCH-END LISPBUILDER-REGEX::MATCH-START)
;             LISPBUILDER-REGEX::*REGS*)
; 
; note: doing signed word to integer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/closure.lisp
; in: DEFUN MAKE-INIT-CLOSURE
;     (FUNCALL LISPBUILDER-REGEX::NEXT LISPBUILDER-REGEX::POS)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::NEXT)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: NEXT is not known to be a function

;     (FUNCALL LISPBUILDER-REGEX::RESET-FN)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::RESET-FN)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-regex/regex.lisp
; in: DEFUN MAKE-ANCHORED-MATCHER
;     (FUNCALL LISPBUILDER-REGEX::MATCHFN LISPBUILDER-REGEX::*START*)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL LISPBUILDER-REGEX::MATCHFN)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: MATCHFN is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-lexer/lexer.lisp
; in: DEFUN GEN-FLEXY-LEXER
;     (DEFUN LISPBUILDER-LEXER::GEN-FLEXY-LEXER
;            (LISPBUILDER-LEXER::NAME LISPBUILDER-LEXER::OPTIONS
;             LISPBUILDER-LEXER::PATTERNS LISPBUILDER-LEXER::ACTIONS)
;       (LET ((LISPBUILDER-LEXER::MATCHERVAR (INTERN # *PACKAGE*))
;             (LISPBUILDER-LEXER::RCVAR (GENSYM))
;             (LISPBUILDER-LEXER::MATCHSTARTVAR (GENSYM))
;             (LISPBUILDER-LEXER::MATCHLENVAR (GENSYM))
;             (LISPBUILDER-LEXER::MATCHREGSVAR (GENSYM))
;             (LISPBUILDER-LEXER::STRVAR (GENSYM))
;             (LISPBUILDER-LEXER::PREVPOSVAR (GENSYM)))
;         `(PROGN
;           (DEFPARAMETER ,LISPBUILDER-LEXER::MATCHERVAR
;             (LISPBUILDER-REGEX:MACROEXPAND-REGEX-EXPR ',#))
;           (DEFUN ,LISPBUILDER-LEXER::NAME
;                  (,LISPBUILDER-LEXER::STRVAR
;                   &KEY # # # #
;                   &AUX # ,LISPBUILDER-LEXER::RCVAR
;                   ,LISPBUILDER-LEXER::MATCHSTARTVAR
;                   ,LISPBUILDER-LEXER::MATCHLENVAR
;                   ,LISPBUILDER-LEXER::MATCHREGSVAR)
;             (DECLARE #
;                      #)
;             (FLET #
;               #)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA LISPBUILDER-LEXER::GEN-FLEXY-LEXER
;         (LISPBUILDER-LEXER::NAME LISPBUILDER-LEXER::OPTIONS
;          LISPBUILDER-LEXER::PATTERNS LISPBUILDER-LEXER::ACTIONS)
;       (BLOCK LISPBUILDER-LEXER::GEN-FLEXY-LEXER
;         (LET ((LISPBUILDER-LEXER::MATCHERVAR #)
;               (LISPBUILDER-LEXER::RCVAR #)
;               (LISPBUILDER-LEXER::MATCHSTARTVAR #)
;               (LISPBUILDER-LEXER::MATCHLENVAR #)
;               (LISPBUILDER-LEXER::MATCHREGSVAR #)
;               (LISPBUILDER-LEXER::STRVAR #)
;               (LISPBUILDER-LEXER::PREVPOSVAR #))
;           `(PROGN
;             (DEFPARAMETER ,LISPBUILDER-LEXER::MATCHERVAR #)
;             (DEFUN ,LISPBUILDER-LEXER::NAME # # #)))))
; 
; caught STYLE-WARNING:
;   The variable OPTIONS is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/lispbuilder/00111fcbcfcbe1220d67deb867b75562d3bbd6df/lispbuilder-20180414-git/lispbuilder-lexer/lexer.lisp
; in: DEFUN GEN-FAST-LEXER
;     (DEFUN LISPBUILDER-LEXER::GEN-FAST-LEXER
;            (LISPBUILDER-LEXER::NAME LISPBUILDER-LEXER::OPTIONS
;             LISPBUILDER-LEXER::PATTERNS LISPBUILDER-LEXER::ACTIONS)
;       (LET ((LISPBUILDER-LEXER::MATCHERVAR (INTERN # *PACKAGE*))
;             (LISPBUILDER-LEXER::RCVAR (GENSYM))
;             (LISPBUILDER-LEXER::MATCHSTARTVAR (GENSYM))
;             (LISPBUILDER-LEXER::MATCHLENVAR (GENSYM))
;             (LISPBUILDER-LEXER::MATCHREGSVAR (GENSYM))
;             (LISPBUILDER-LEXER::STRVAR (GENSYM))
;             (LISPBUILDER-LEXER::PREVPOSVAR (GENSYM)))
;         `(PROGN
;           (DEFPARAMETER ,LISPBUILDER-LEXER::MATCHERVAR
;             (LISPBUILDER-REGEX:MACROEXPAND-REGEX-EXPR ',#))
;           (DEFUN ,LISPBUILDER-LEXER::NAME
;                  (,LISPBUILDER-LEXER::STRVAR
;                   &KEY # # # #
;                   &AUX # ,LISPBUILDER-LEXER::RCVAR
;                   ,LISPBUILDER-LEXER::MATCHSTARTVAR
;                   ,LISPBUILDER-LEXER::MATCHLENVAR
;                   ,LISPBUILDER-LEXER::MATCHREGSVAR)
;             (DECLARE #
;                      #)
;             (FLET #
;               #)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA LISPBUILDER-LEXER::GEN-FAST-LEXER
;         (LISPBUILDER-LEXER::NAME LISPBUILDER-LEXER::OPTIONS
;          LISPBUILDER-LEXER::PATTERNS LISPBUILDER-LEXER::ACTIONS)
;       (BLOCK LISPBUILDER-LEXER::GEN-FAST-LEXER
;         (LET ((LISPBUILDER-LEXER::MATCHERVAR #)
;               (LISPBUILDER-LEXER::RCVAR #)
;               (LISPBUILDER-LEXER::MATCHSTARTVAR #)
;               (LISPBUILDER-LEXER::MATCHLENVAR #)
;               (LISPBUILDER-LEXER::MATCHREGSVAR #)
;               (LISPBUILDER-LEXER::STRVAR #)
;               (LISPBUILDER-LEXER::PREVPOSVAR #))
;           `(PROGN
;             (DEFPARAMETER ,LISPBUILDER-LEXER::MATCHERVAR #)
;             (DEFUN ,LISPBUILDER-LEXER::NAME # # #)))))
; 
; caught STYLE-WARNING:
;   The variable OPTIONS is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "lispbuilder-lexer" "lexer">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/de.setf.wilbur/6b3398d5a1e900db744abc3418ad50a40490abae/de.setf.wilbur-20180414-git/src/nox/xml-util.lisp
; in: DEFINE-RESOURCE-POOL *XML-PARSE-BUFFERS*
;     (WILBUR:DEFINE-RESOURCE-POOL WILBUR::*XML-PARSE-BUFFERS*
;                                  #'(LAMBDA ()
;                                      (WILBUR::MAKE-BASE-STRING 2048 :ADJUSTABLE T
;                                       :FILL-POINTER 0))
;                                  #'(LAMBDA (VECTOR)
;                                      (SETF (FILL-POINTER VECTOR) 0)))
; --> DEFPARAMETER PROGN 
; ==>
;   (SB-IMPL::%DEFPARAMETER 'WILBUR::*XML-PARSE-BUFFERS*
;                           (WILBUR::MAKE-RESOURCE-POOL :CONSTRUCTOR
;                            #'(LAMBDA ()
;                                (WILBUR::MAKE-BASE-STRING 2048 :ADJUSTABLE T
;                                 :FILL-POINTER 0))
;                            :INITIALIZER #'(LAMBDA (VECTOR) (SETF # 0))
;                            :DESTRUCTOR NIL)
;                           (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Call to WILBUR::MAKE-BASE-STRING could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "wilbur" "nox" "xml-util">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/de.setf.wilbur/6b3398d5a1e900db744abc3418ad50a40490abae/de.setf.wilbur-20180414-git/src/nox/xml-parser.lisp
; in: DEFUN ENDS-IN-HASH-P
;     (CHAR STRING (1- (LENGTH STRING)))
; --> AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/de.setf.wilbur/6b3398d5a1e900db744abc3418ad50a40490abae/de.setf.wilbur-20180414-git/src/core/hash-table.lisp
; in:
;      DECLAIM (INLINE WILBUR-MAKE-HASH-TABLE WILBUR-GETHASH (SETF WILBUR-GETHASH) WILBUR-REMHASH WILBUR-CLRHASH WILBUR-HASH-TABLE-COUNT WILBUR-HASH-TABLE-SIZE WILBUR-MAPHASH)
;     (DECLAIM
;      (INLINE WILBUR::WILBUR-MAKE-HASH-TABLE WILBUR::WILBUR-GETHASH
;       (SETF WILBUR::WILBUR-GETHASH) WILBUR::WILBUR-REMHASH WILBUR::WILBUR-CLRHASH
;       WILBUR::WILBUR-HASH-TABLE-COUNT WILBUR::WILBUR-HASH-TABLE-SIZE
;       WILBUR::WILBUR-MAPHASH))
; --> EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM
;    '(INLINE WILBUR::WILBUR-MAKE-HASH-TABLE WILBUR::WILBUR-GETHASH
;      (SETF WILBUR::WILBUR-GETHASH) WILBUR::WILBUR-REMHASH
;      WILBUR::WILBUR-CLRHASH WILBUR::WILBUR-HASH-TABLE-COUNT
;      WILBUR::WILBUR-HASH-TABLE-SIZE WILBUR::WILBUR-MAPHASH)
;    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming (COMMON-LISP:SETF WILBUR::WILBUR-GETHASH) to be INLINE, but 1 call to it was previously compiled. A declaration of NOTINLINE at the call site will eliminate this warning, as will proclaiming and defining the function before its first potential use.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "wilbur" "core" "hash-table">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/de.setf.wilbur/6b3398d5a1e900db744abc3418ad50a40490abae/de.setf.wilbur-20180414-git/src/core/data.lisp
; in: DEFMETHOD DB-QUERY (DB T T T)
;     (DEFMETHOD WILBUR:DB-QUERY
;                ((WILBUR:DB WILBUR:DB) WILBUR::SUBJECT WILBUR::PREDICATE
;                 WILBUR::OBJECT)
;       (FLET ((WILBUR::MATCHING-TRIPLE-P (WILBUR:TRIPLE)
;                (AND # # #)))
;         (DECLARE (DYNAMIC-EXTENT (FUNCTION WILBUR::MATCHING-TRIPLE-P)))
;         (REMOVE-IF-NOT #'WILBUR::MATCHING-TRIPLE-P
;                        (WILBUR:DB-TRIPLES WILBUR:DB))))
; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; ==>
;   (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'WILBUR:DB-QUERY 'NIL
;                           (LIST (FIND-CLASS 'WILBUR:DB) (FIND-CLASS 'T)
;                                 (FIND-CLASS 'T) (FIND-CLASS 'T))
;                           '(WILBUR:DB WILBUR::SUBJECT WILBUR::PREDICATE
;                             WILBUR::OBJECT)
;                           (LIST* :FUNCTION
;                                  (LET* ((SB-PCL::FMF #) (SB-PCL::MF #))
;                                    (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
;                                     SB-PCL::MF
;                                     (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
;                                      SB-PCL::FMF '#))
;                                    SB-PCL::MF)
;                                  '(SB-PCL::PLIST (:ARG-INFO (4))
;                                    SB-PCL::SIMPLE-NEXT-METHOD-CALL T))
;                           (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Call to WILBUR::EQ~ could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/de.setf.wilbur/6b3398d5a1e900db744abc3418ad50a40490abae/de.setf.wilbur-20180414-git/src/core/data.lisp
; in: DEFUN MAKE-TRIPLE-INDEX
;     (DEFUN WILBUR::MAKE-TRIPLE-INDEX (WILBUR::MULTIPLE-COMPONENTS-P)
;       (DECLARE (IGNORE WILBUR::MULTIPLE-COMPONENTS-P))
;       (WILBUR::WILBUR-MAKE-HASH-TABLE :TEST #'EQ))
; --> PROGN 
; ==>
;   (SB-IMPL::%DEFUN 'WILBUR::MAKE-TRIPLE-INDEX
;                    (SB-INT:NAMED-LAMBDA WILBUR::MAKE-TRIPLE-INDEX
;                        (WILBUR::MULTIPLE-COMPONENTS-P)
;                      (DECLARE (IGNORE WILBUR::MULTIPLE-COMPONENTS-P))
;                      (BLOCK WILBUR::MAKE-TRIPLE-INDEX
;                        (WILBUR::WILBUR-MAKE-HASH-TABLE :TEST #'EQ))))
; 
; caught STYLE-WARNING:
;   Call to WILBUR::WILBUR-MAKE-HASH-TABLE could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/de.setf.wilbur/6b3398d5a1e900db744abc3418ad50a40490abae/de.setf.wilbur-20180414-git/src/core/data.lisp
; in: DEFUN TRIPLE-INDEX-CLEAR
;     (DEFUN WILBUR::TRIPLE-INDEX-CLEAR (WILBUR::INDEX)
;       (WILBUR::WILBUR-CLRHASH WILBUR::INDEX))
; --> PROGN 
; ==>
;   (SB-IMPL::%DEFUN 'WILBUR::TRIPLE-INDEX-CLEAR
;                    (SB-INT:NAMED-LAMBDA WILBUR::TRIPLE-INDEX-CLEAR
;                        (WILBUR::INDEX)
;                      (BLOCK WILBUR::TRIPLE-INDEX-CLEAR
;                        (WILBUR::WILBUR-CLRHASH WILBUR::INDEX))))
; 
; caught STYLE-WARNING:
;   Call to WILBUR::WILBUR-CLRHASH could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/de.setf.wilbur/6b3398d5a1e900db744abc3418ad50a40490abae/de.setf.wilbur-20180414-git/src/core/data.lisp
; in: DEFUN %TRIPLE-INDEX-ADD-SINGLE
;     (DEFUN WILBUR::%TRIPLE-INDEX-ADD-SINGLE
;            (WILBUR:TRIPLE WILBUR::INDEX WILBUR::COMPONENT)
;       (PUSH WILBUR:TRIPLE
;             (WILBUR::WILBUR-GETHASH WILBUR::COMPONENT WILBUR::INDEX)))
; --> PROGN 
; ==>
;   (SB-IMPL::%DEFUN 'WILBUR::%TRIPLE-INDEX-ADD-SINGLE
;                    (SB-INT:NAMED-LAMBDA WILBUR::%TRIPLE-INDEX-ADD-SINGLE
;                        (WILBUR:TRIPLE WILBUR::INDEX WILBUR::COMPONENT)
;                      (BLOCK WILBUR::%TRIPLE-INDEX-ADD-SINGLE
;                        (PUSH WILBUR:TRIPLE
;                              (WILBUR::WILBUR-GETHASH WILBUR::COMPONENT
;                                                      WILBUR::INDEX)))))
; 
; caught STYLE-WARNING:
;   Call to WILBUR::WILBUR-GETHASH could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.
; 
; caught STYLE-WARNING:
;   Call to (COMMON-LISP:SETF WILBUR::WILBUR-GETHASH) could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/de.setf.wilbur/6b3398d5a1e900db744abc3418ad50a40490abae/de.setf.wilbur-20180414-git/src/core/data.lisp
; in: DEFUN %TRIPLE-INDEX-ADD-DOUBLE
;     (DEFUN WILBUR::%TRIPLE-INDEX-ADD-DOUBLE
;            (WILBUR:TRIPLE WILBUR::INDEX WILBUR::C1 WILBUR::C2)
;       (PUSH WILBUR:TRIPLE
;             (WILBUR::WILBUR-GETHASH WILBUR::C2
;                                     (WILBUR::ENSURE-SUB-INDEX WILBUR::C1
;                                      WILBUR::INDEX))))
; --> PROGN 
; ==>
;   (SB-IMPL::%DEFUN 'WILBUR::%TRIPLE-INDEX-ADD-DOUBLE
;                    (SB-INT:NAMED-LAMBDA WILBUR::%TRIPLE-INDEX-ADD-DOUBLE
;                        (WILBUR:TRIPLE WILBUR::INDEX WILBUR::C1 WILBUR::C2)
;                      (BLOCK WILBUR::%TRIPLE-INDEX-ADD-DOUBLE
;                        (PUSH WILBUR:TRIPLE
;                              (WILBUR::WILBUR-GETHASH WILBUR::C2 #)))))
; 
; caught STYLE-WARNING:
;   Call to WILBUR::ENSURE-SUB-INDEX could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/de.setf.wilbur/6b3398d5a1e900db744abc3418ad50a40490abae/de.setf.wilbur-20180414-git/src/core/data.lisp
; in: DEFUN TRIPLE-COLLECTION-ADD
;     (DEFUN WILBUR:TRIPLE-COLLECTION-ADD (WILBUR::COLLECTION WILBUR:TRIPLE)
;       (OR (WILBUR::TRIPLE-COLLECTION-FIND WILBUR::COLLECTION WILBUR:TRIPLE)
;           (PROGN
;            (PUSH WILBUR:TRIPLE
;                  (WILBUR:TRIPLE-COLLECTION-TRIPLES WILBUR::COLLECTION))
;            (WILBUR::TRIPLE-INDEX-ADD WILBUR:TRIPLE
;                                      (WILBUR::TRIPLE-COLLECTION-INDEX
;                                       WILBUR::COLLECTION)
;                                      (WILBUR:TRIPLE-PREDICATE WILBUR:TRIPLE)
;                                      (WILBUR:TRIPLE-SUBJECT WILBUR:TRIPLE))
;            WILBUR:TRIPLE)))
; --> PROGN 
; ==>
;   (SB-IMPL::%DEFUN 'WILBUR:TRIPLE-COLLECTION-ADD
;                    (SB-INT:NAMED-LAMBDA WILBUR:TRIPLE-COLLECTION-ADD
;                        (WILBUR::COLLECTION WILBUR:TRIPLE)
;                      (BLOCK WILBUR:TRIPLE-COLLECTION-ADD
;                        (OR
;                         (WILBUR::TRIPLE-COLLECTION-FIND WILBUR::COLLECTION
;                          WILBUR:TRIPLE)
;                         (PROGN # # WILBUR:TRIPLE)))))
; 
; caught STYLE-WARNING:
;   Call to WILBUR::%TRIPLE-INDEX-ADD-DOUBLE could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/de.setf.wilbur/6b3398d5a1e900db744abc3418ad50a40490abae/de.setf.wilbur-20180414-git/src/core/data.lisp
; in: DEFMETHOD DB-ADD-TRIPLE (INDEXED-DB TRIPLE)
;     (DEFMETHOD WILBUR:DB-ADD-TRIPLE
;                ((WILBUR:DB WILBUR:INDEXED-DB) (WILBUR:TRIPLE WILBUR:TRIPLE)
;                 &OPTIONAL WILBUR::SOURCE)
;       (DECLARE (IGNORE WILBUR::SOURCE))
;       (MULTIPLE-VALUE-BIND
;           (WILBUR::ACTUAL-TRIPLE WILBUR::ADDEDP WILBUR::NEW-SOURCES)
;           (CALL-NEXT-METHOD)
;         (COND
;          (WILBUR::ADDEDP
;           (LET #
;             #
;             #
;             #
;             #
;             #
;             #
;             #))
;          (WILBUR::NEW-SOURCES (DOLIST # #)
;           (VALUES WILBUR::ACTUAL-TRIPLE NIL WILBUR::NEW-SOURCES))
;          (T (VALUES WILBUR::ACTUAL-TRIPLE NIL NIL)))))
; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; ==>
;   (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'WILBUR:DB-ADD-TRIPLE 'NIL
;                           (LIST (FIND-CLASS 'WILBUR:INDEXED-DB)
;                                 (FIND-CLASS 'WILBUR:TRIPLE))
;                           '(WILBUR:DB WILBUR:TRIPLE &OPTIONAL WILBUR::SOURCE)
;                           (LIST* :FUNCTION
;                                  (LET* ((SB-PCL::FMF #) (SB-PCL::MF #))
;                                    (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
;                                     SB-PCL::MF
;                                     (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
;                                      SB-PCL::FMF '#))
;                                    SB-PCL::MF)
;                                  '(SB-PCL::PLIST (:ARG-INFO (2 . T))
;                                    SB-PCL::METHOD-CELL (#:METHOD-CELL)
;                                    SB-PCL::SIMPLE-NEXT-METHOD-CALL T))
;                           (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Call to WILBUR::%TRIPLE-INDEX-ADD-SINGLE could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/de.setf.wilbur/6b3398d5a1e900db744abc3418ad50a40490abae/de.setf.wilbur-20180414-git/src/core/data.lisp
; in: DEFMETHOD DB-DEL-TRIPLE (INDEXED-DB TRIPLE)
;     (DEFMETHOD WILBUR:DB-DEL-TRIPLE
;                ((WILBUR:DB WILBUR:INDEXED-DB) (WILBUR:TRIPLE WILBUR:TRIPLE)
;                 &OPTIONAL WILBUR::SOURCE)
;       (LET ((WILBUR::SOURCES (WILBUR:TRIPLE-SOURCES WILBUR:TRIPLE)))
;         (MULTIPLE-VALUE-BIND (WILBUR:TRIPLE WILBUR::DELETEDP WILBUR::NEW-SOURCES)
;             (CALL-NEXT-METHOD)
;           (COND (WILBUR::DELETEDP #) (T # #)))))
; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; ==>
;   (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'WILBUR:DB-DEL-TRIPLE 'NIL
;                           (LIST (FIND-CLASS 'WILBUR:INDEXED-DB)
;                                 (FIND-CLASS 'WILBUR:TRIPLE))
;                           '(WILBUR:DB WILBUR:TRIPLE &OPTIONAL WILBUR::SOURCE)
;                           (LIST* :FUNCTION
;                                  (LET* ((SB-PCL::FMF #) (SB-PCL::MF #))
;                                    (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
;                                     SB-PCL::MF
;                                     (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
;                                      SB-PCL::FMF '#))
;                                    SB-PCL::MF)
;                                  '(SB-PCL::PLIST (:ARG-INFO (2 . T))
;                                    SB-PCL::METHOD-CELL (#:METHOD-CELL)
;                                    SB-PCL::SIMPLE-NEXT-METHOD-CALL T))
;                           (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Call to WILBUR::%TRIPLE-INDEX-REM-DOUBLE could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.
; 
; caught STYLE-WARNING:
;   Call to WILBUR::%TRIPLE-INDEX-REM-SINGLE could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/de.setf.wilbur/6b3398d5a1e900db744abc3418ad50a40490abae/de.setf.wilbur-20180414-git/src/core/data.lisp
; in: DEFMETHOD DB-SOURCES (INDEXED-DB)
;     (DEFMETHOD WILBUR:DB-SOURCES ((WILBUR:DB WILBUR:INDEXED-DB))
;       (LET ((WILBUR::SOURCES NIL))
;         (WILBUR::WILBUR-MAPHASH
;          #'(LAMBDA (WILBUR::KEY WILBUR::DATA)
;              (DECLARE #)
;              (PUSH WILBUR::KEY WILBUR::SOURCES))
;          (WILBUR::DB-BY-SOURCE WILBUR:DB))
;         WILBUR::SOURCES))
; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; ==>
;   (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'WILBUR:DB-SOURCES 'NIL
;                           (LIST (FIND-CLASS 'WILBUR:INDEXED-DB)) '(WILBUR:DB)
;                           (LIST* :FUNCTION
;                                  (LET* ((SB-PCL::FMF #) (SB-PCL::MF #))
;                                    (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
;                                     SB-PCL::MF
;                                     (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
;                                      SB-PCL::FMF '#))
;                                    SB-PCL::MF)
;                                  '(SB-PCL::PLIST (:ARG-INFO (1))
;                                    SB-PCL::SIMPLE-NEXT-METHOD-CALL T))
;                           (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Call to WILBUR::WILBUR-MAPHASH could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "wilbur" "core" "data">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/de.setf.wilbur/6b3398d5a1e900db744abc3418ad50a40490abae/de.setf.wilbur-20180414-git/src/core/http.lisp
; in: DEFUN SUBSTRING
;     (CHAR STRING WILBUR::R-INDEX)
; --> AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (CHAR-DOWNCASE WILBUR::C)
; 
; note: unable to open code due to type uncertainty: The first argument is a CHARACTER, not a BASE-CHAR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/de.setf.wilbur/6b3398d5a1e900db744abc3418ad50a40490abae/de.setf.wilbur-20180414-git/src/core/wilbur-ql.lisp
; in: DEFSTRUCT INVERSE-SLOT
;     (DEFSTRUCT
;         (WILBUR::INVERSE-SLOT (:COPIER NIL)
;          (:CONSTRUCTOR WILBUR::%MAKE-INVERSE-SLOT (WILBUR:NODE)))
;       WILBUR:NODE)
; --> PROGN EVAL-WHEN 
; ==>
;   (SB-KERNEL::%COMPILER-DEFSTRUCT
;    '#<SB-KERNEL:DEFSTRUCT-DESCRIPTION WILBUR::INVERSE-SLOT {1002019393}>
;    '#(#<SB-KERNEL:LAYOUT for T {20300003}>
;       #<SB-KERNEL:LAYOUT for STRUCTURE-OBJECT {20300103}>))
; 
; caught STYLE-WARNING:
;   Previously compiled call to WILBUR::INVERSE-SLOT-NODE could not be inlined because the structure definition for WILBUR::INVERSE-SLOT was not yet seen. To avoid this warning, DEFSTRUCT should precede references to the affected functions, or they must be declared locally notinline at each call site.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/de.setf.wilbur/6b3398d5a1e900db744abc3418ad50a40490abae/de.setf.wilbur-20180414-git/src/core/wilbur-ql.lisp
; in: DEFSTRUCT DEFAULT-VALUE
;     (DEFSTRUCT
;         (WILBUR::DEFAULT-VALUE (:COPIER NIL)
;          (:CONSTRUCTOR WILBUR::MAKE-DEFAULT-VALUE (WILBUR:VALUE)))
;       WILBUR:VALUE)
; --> PROGN EVAL-WHEN 
; ==>
;   (SB-KERNEL::%COMPILER-DEFSTRUCT
;    '#<SB-KERNEL:DEFSTRUCT-DESCRIPTION WILBUR::DEFAULT-VALUE {100218E8D3}>
;    '#(#<SB-KERNEL:LAYOUT for T {20300003}>
;       #<SB-KERNEL:LAYOUT for STRUCTURE-OBJECT {20300103}>))
; 
; caught STYLE-WARNING:
;   Previously compiled call to WILBUR::DEFAULT-VALUE-VALUE could not be inlined because the structure definition for WILBUR::DEFAULT-VALUE was not yet seen. To avoid this warning, DEFSTRUCT should precede references to the affected functions, or they must be declared locally notinline at each call site.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "wilbur" "core" "wilbur-ql">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/de.setf.wilbur/6b3398d5a1e900db744abc3418ad50a40490abae/de.setf.wilbur-20180414-git/src/core/reasoner.lisp
; in:
;      DEFMETHOD DB-NODE-PROPERTIES-PARTITIONED (DEDUCTIVE-CLOSURE-DB-MIXIN NODE)
;     (MAPCAR #'WILBUR:TRIPLE-OBJECT WILBUR::TYPE-PROPS)
; --> LET LET SB-INT:DO-ANONYMOUS BLOCK LET 
; ==>
;   WILBUR::TYPE-PROPS
; 
; note: deleting unreachable code

;     (WILBUR::SORT-TYPES (MAPCAR #'WILBUR:TRIPLE-OBJECT WILBUR::TYPE-PROPS)
;      WILBUR:DB)
; ==>
;   WILBUR:DB
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-conllu/48b1376d0baa934011ace3e27e74594eadf1bd02/cl-conllu-20180414-git/evaluate.lisp
; in: DEFUN EXACT-MATCH
;     (DEFUN CL-CONLLU::EXACT-MATCH
;            (CL-CONLLU::LIST-SENT1 CL-CONLLU::LIST-SENT2
;             (CL-CONLLU::COMPARED-FIELDS
;              '(CL-CONLLU:UPOSTAG CL-CONLLU:FEATS CL-CONLLU::HEAD
;                CL-CONLLU:DEPREL))
;             (CL-CONLLU::IDENTITY-FIELDS '(CL-CONLLU::ID CL-CONLLU:FORM))
;             (CL-CONLLU::TEST #'EQUAL) (CL-CONLLU::SIMPLE-DEP NIL)
;             (CL-CONLLU::IGNORE-PUNCT NIL))
;       #<(SIMPLE-ARRAY CHARACTER
;          (437)) Returns the percentage of sentences of LIST-SENT1 that are an exact
;     match to LIST-SENT2.
;   
;     LIST-SENT1 and LIST-SENT2 must have the same size with corresponding
;     sentences in order.
;   
;     The typical ... {100C2BAF3F}>
;       (ASSERT
;        (EQUAL (LENGTH CL-CONLLU::LIST-SENT1) (LENGTH CL-CONLLU::LIST-SENT2)))
;       (LET ((CL-CONLLU::N (FLOAT #)) (CL-CONLLU::CORRECT-SENTENCES (COUNT T #)))
;         (/ CL-CONLLU::CORRECT-SENTENCES CL-CONLLU::N)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-CONLLU::EXACT-MATCH
;         (CL-CONLLU::LIST-SENT1 CL-CONLLU::LIST-SENT2
;          (CL-CONLLU::COMPARED-FIELDS
;           '(CL-CONLLU:UPOSTAG CL-CONLLU:FEATS CL-CONLLU::HEAD
;             CL-CONLLU:DEPREL))
;          (CL-CONLLU::IDENTITY-FIELDS '(CL-CONLLU::ID CL-CONLLU:FORM))
;          (CL-CONLLU::TEST #'EQUAL) (CL-CONLLU::SIMPLE-DEP NIL)
;          (CL-CONLLU::IGNORE-PUNCT NIL))
;       #<(SIMPLE-ARRAY CHARACTER
;          (437)) Returns the percentage of sentences of LIST-SENT1 that are an exact
;   match to LIST-SENT2.
; 
;   LIST-SENT1 and LIST-SENT2 must have the same size with corresponding
;   sentences in order.
; 
;   The typical ... {100C2BAF3F}>
;       (BLOCK CL-CONLLU::EXACT-MATCH
;         (ASSERT
;          (EQUAL (LENGTH CL-CONLLU::LIST-SENT1) (LENGTH CL-CONLLU::LIST-SENT2)))
;         (LET ((CL-CONLLU::N #) (CL-CONLLU::CORRECT-SENTENCES #))
;           (/ CL-CONLLU::CORRECT-SENTENCES CL-CONLLU::N))))
; 
; caught ERROR:
;   Required argument is not a symbol: (COMPARED-FIELDS (QUOTE (UPOSTAG FEATS HEAD DEPREL)))
Unhandled UIOP/LISP-BUILD:COMPILE-FILE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING {10006105B3}>: COMPILE-FILE-ERROR while compiling #<CL-SOURCE-FILE "cl-conllu" "evaluate">

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {10006105B3}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {100C7CF683}> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {100C7CF683}>)
2: (INVOKE-DEBUGGER #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {100C7CF683}>)
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 "cl-conllu" "evaluate">)))
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 "cl-conllu" "evaluate">)))
5: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "cl-conllu" "evaluate">)
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 "cl-conllu" "evaluate">) [fast-method]
8: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {10058D17E3}>) [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 {10058D17E3}>) [fast-method]
11: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "cl-conllu"> :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 "cl-conllu">)
13: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
14: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "cl-conllu">) [fast-method]
15: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "cl-conllu")
16: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
17: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "cl-conllu") [fast-method]
18: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {10058CC0BB}> :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) {1005888DEB}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
21: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "cl-conllu") [fast-method]
22: (DEPCHECK::COMPUTE-DEPENDENCIES "cl-conllu" "cl-conllu")
23: (DEPCHECK::MAGIC "cl-conllu" "cl-conllu" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-fPdqkXCs/depcheck-win.txt")
24: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "cl-conllu" "cl-conllu" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-fPdqkXCs/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-fPdqkXCs/depcheck-fail.txt"))
25: ((LAMBDA NIL :IN "/home/quicklisp/src/quicklisp-controller/dumper-2SKVI5f7.lisp"))
26: ((FLET SB-UNIX::BODY :IN SAVE-LISP-AND-DIE))
27: ((FLET "WITHOUT-INTERRUPTS-BODY-36" :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 ERROR condition
;   caught 17 STYLE-WARNING conditions
;   printed 168 notes