cl-irregsexp

SBCL 1.4.4 / ASDF 3.3.1

cl-irregsexp-test

WARNING: UIOP/VERSION:PARSE-VERSION: "prerelease" doesn't follow asdf version numbering convention
WARNING: Invalid :version specifier "prerelease" for component "cl-irregsexp-test" from file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-irregsexp/40dd190eaf28eea03b2208469408590b390d07c2/cl-irregsexp-20180202-git/cl-irregsexp-test.asd", using NIL instead
WARNING: Invalid :version specifier "prerelease" for component "cl-irregsexp-test" from file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-irregsexp/40dd190eaf28eea03b2208469408590b390d07c2/cl-irregsexp-20180202-git/cl-irregsexp-test.asd", using NIL instead
WARNING: UIOP/VERSION:PARSE-VERSION: "prerelease" doesn't follow asdf version numbering convention
WARNING: Invalid :version specifier "prerelease" for component "cl-irregsexp" from file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-irregsexp/40dd190eaf28eea03b2208469408590b390d07c2/cl-irregsexp-20180202-git/cl-irregsexp.asd", using NIL instead
WARNING: Invalid :version specifier "prerelease" for component "cl-irregsexp" from file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-irregsexp/40dd190eaf28eea03b2208469408590b390d07c2/cl-irregsexp-20180202-git/cl-irregsexp.asd", using NIL instead

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-irregsexp/40dd190eaf28eea03b2208469408590b390d07c2/cl-irregsexp-20180202-git/src/macros.lisp
; in: DEFINE-ALIST-GET ALIST-GET
;     (CL-IRREGSEXP::DEFINE-ALIST-GET CL-IRREGSEXP.UTILS:ALIST-GET ASSOC CDR ACONS)
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION BLOCK LOOP BLOCK LET LET TAGBODY WHEN IF FUNCALL SB-C::%FUNCALL 
; --> THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN CL-IRREGSEXP::TEST)
; 
; 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/cl-irregsexp/40dd190eaf28eea03b2208469408590b390d07c2/cl-irregsexp-20180202-git/src/macros.lisp
; in: DEFINE-ALIST-GET RALIST-GET
;     (CL-IRREGSEXP::DEFINE-ALIST-GET CL-IRREGSEXP::RALIST-GET RASSOC CAR
;      CL-IRREGSEXP::RACONS)
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION BLOCK LOOP BLOCK LET LET TAGBODY WHEN IF FUNCALL SB-C::%FUNCALL 
; --> THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN CL-IRREGSEXP::TEST)
; 
; 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/cl-irregsexp/40dd190eaf28eea03b2208469408590b390d07c2/cl-irregsexp-20180202-git/src/byte-vector.lisp
; in: DEFUN-SPEEDY MAKE-BYTE-VECTOR
;     (CL-IRREGSEXP.UTILS:DEFUN-SPEEDY CL-IRREGSEXP.BYTESTRINGS:MAKE-BYTE-VECTOR
;         (CL-IRREGSEXP::LEN)
;       (DECLARE (TYPE (UNSIGNED-BYTE *) CL-IRREGSEXP::LEN))
;       (MAKE-ARRAY CL-IRREGSEXP::LEN :ELEMENT-TYPE '(UNSIGNED-BYTE 8)))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET UNLESS IF TYPEP LET 
; --> SB-C::%TYPEP-WRAPPER LET AND IF LOCALLY AND THE >= IF >= IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-irregsexp/40dd190eaf28eea03b2208469408590b390d07c2/cl-irregsexp-20180202-git/src/utf8.lisp
; in: DEFUN-CONSISTENT UTF8-ENCODE
;     (CL-IRREGSEXP.UTILS:DEFUN-CONSISTENT CL-IRREGSEXP.BYTESTRINGS:UTF8-ENCODE
;         (CL-IRREGSEXP::STR)
;       (DECLARE (TYPE SIMPLE-STRING CL-IRREGSEXP::STR))
;       (DECLARE (OPTIMIZE SPEED))
;       (LET ((CL-IRREGSEXP::VEC (CL-IRREGSEXP.BYTESTRINGS:MAKE-BYTE-VECTOR #)))
;         (LOOP CL-IRREGSEXP::FOR CL-IRREGSEXP::I FIXNUM CL-IRREGSEXP::FROM 0
;               CL-IRREGSEXP::FOR CL-IRREGSEXP::S CL-IRREGSEXP::ACROSS CL-IRREGSEXP::STR
;               DO (LET (#)
;                    (WHEN # # #)
;                    (SETF #)))
;         CL-IRREGSEXP::VEC))
; --> PROGN CL-IRREGSEXP.UTILS:DEFUN-CAREFUL PROGN DEFUN PROGN SB-IMPL::%DEFUN 
; --> SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-IRREGSEXP.BYTESTRINGS::UTF8-ENCODE-CONSISTENT-INTERNAL-CAREFUL
;         (CL-IRREGSEXP::STR)
;       (DECLARE (OPTIMIZE DEBUG SAFETY (SPEED 0)))
;       (DECLARE (TYPE SIMPLE-STRING CL-IRREGSEXP::STR))
;       (DECLARE (OPTIMIZE SPEED))
;       (BLOCK CL-IRREGSEXP.BYTESTRINGS::UTF8-ENCODE-CONSISTENT-INTERNAL-CAREFUL
;         (LET ((CL-IRREGSEXP::VEC #))
;           (LOOP CL-IRREGSEXP::FOR CL-IRREGSEXP::I FIXNUM CL-IRREGSEXP::FROM 0
;                 CL-IRREGSEXP::FOR CL-IRREGSEXP::S CL-IRREGSEXP::ACROSS CL-IRREGSEXP::STR
;                 DO (LET #
;                      #
;                      #))
;           CL-IRREGSEXP::VEC)))
; 
; caught STYLE-WARNING:
;   Repeated OPTIMIZE quality. Using (SPEED 3)
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "cl-irregsexp" "src" "utf8">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-irregsexp/40dd190eaf28eea03b2208469408590b390d07c2/cl-irregsexp-20180202-git/src/force.lisp
; in: DEFUN-CONSISTENT FORCE-STRING
;     (PRINC-TO-STRING CL-IRREGSEXP::VAL)
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a NUMBER.
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a NUMBER.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-irregsexp/40dd190eaf28eea03b2208469408590b390d07c2/cl-irregsexp-20180202-git/src/force.lisp
; in: DEFUN-CONSISTENT FORCE-BYTE-VECTOR
;     (COERCE CL-IRREGSEXP::VAL 'CL-IRREGSEXP.BYTESTRINGS:BYTE-VECTOR)
; --> THE IF REPLACE MAKE-ARRAY 
; ==>
;   (LENGTH SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; --> THE IF 
; ==>
;   (REPLACE (MAKE-ARRAY (LENGTH SB-C::X) :ELEMENT-TYPE '(UNSIGNED-BYTE 8))
;            SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).

; --> THE IF REPLACE MAKE-ARRAY 
; ==>
;   (LENGTH SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; --> THE IF 
; ==>
;   (REPLACE (MAKE-ARRAY (LENGTH SB-C::X) :ELEMENT-TYPE '(UNSIGNED-BYTE 8))
;            SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-irregsexp/40dd190eaf28eea03b2208469408590b390d07c2/cl-irregsexp-20180202-git/src/force.lisp
; in: DEFUN-CONSISTENT FORCE-SIMPLE-BYTE-VECTOR
;     (CL-IRREGSEXP.BYTESTRINGS:FORCE-BYTE-VECTOR CL-IRREGSEXP::VAL)
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF REPLACE MAKE-ARRAY 
; ==>
;   (LENGTH SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF 
; ==>
;   (REPLACE (MAKE-ARRAY (LENGTH SB-C::X) :ELEMENT-TYPE '(UNSIGNED-BYTE 8))
;            SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).

; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF REPLACE MAKE-ARRAY 
; ==>
;   (LENGTH SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF 
; ==>
;   (REPLACE (MAKE-ARRAY (LENGTH SB-C::X) :ELEMENT-TYPE '(UNSIGNED-BYTE 8))
;            SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).

; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF REPLACE MAKE-ARRAY 
; ==>
;   (LENGTH SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF 
; ==>
;   (REPLACE (MAKE-ARRAY (LENGTH SB-C::X) :ELEMENT-TYPE '(UNSIGNED-BYTE 8))
;            SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-irregsexp/40dd190eaf28eea03b2208469408590b390d07c2/cl-irregsexp-20180202-git/src/force.lisp
; in: DEFUN-CONSISTENT BYTE-VECTOR-TO-STRING
;     (CL-IRREGSEXP.BYTESTRINGS:UTF8-DECODE
;      (CL-IRREGSEXP.BYTESTRINGS:FORCE-SIMPLE-BYTE-VECTOR CL-IRREGSEXP::VEC))
; --> CL-IRREGSEXP.BYTESTRINGS::UTF8-DECODE-CONSISTENT-INTERNAL 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL 
; --> BLOCK LET CL-IRREGSEXP.BYTESTRINGS:FORCE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF REPLACE MAKE-ARRAY 
; ==>
;   (LENGTH SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; --> CL-IRREGSEXP.BYTESTRINGS::UTF8-DECODE-CONSISTENT-INTERNAL 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL 
; --> BLOCK LET CL-IRREGSEXP.BYTESTRINGS:FORCE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF 
; ==>
;   (REPLACE (MAKE-ARRAY (LENGTH SB-C::X) :ELEMENT-TYPE '(UNSIGNED-BYTE 8))
;            SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).

; --> CL-IRREGSEXP.BYTESTRINGS::UTF8-DECODE-CONSISTENT-INTERNAL 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL 
; --> BLOCK LET CL-IRREGSEXP.BYTESTRINGS:FORCE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF REPLACE MAKE-ARRAY 
; ==>
;   (LENGTH SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; --> CL-IRREGSEXP.BYTESTRINGS::UTF8-DECODE-CONSISTENT-INTERNAL 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL 
; --> BLOCK LET CL-IRREGSEXP.BYTESTRINGS:FORCE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF 
; ==>
;   (REPLACE (MAKE-ARRAY (LENGTH SB-C::X) :ELEMENT-TYPE '(UNSIGNED-BYTE 8))
;            SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).

; --> CL-IRREGSEXP.BYTESTRINGS::UTF8-DECODE-CONSISTENT-INTERNAL 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL 
; --> BLOCK LET CL-IRREGSEXP.BYTESTRINGS:FORCE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF REPLACE MAKE-ARRAY 
; ==>
;   (LENGTH SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; --> CL-IRREGSEXP.BYTESTRINGS::UTF8-DECODE-CONSISTENT-INTERNAL 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL 
; --> BLOCK LET CL-IRREGSEXP.BYTESTRINGS:FORCE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF 
; ==>
;   (REPLACE (MAKE-ARRAY (LENGTH SB-C::X) :ELEMENT-TYPE '(UNSIGNED-BYTE 8))
;            SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-irregsexp/40dd190eaf28eea03b2208469408590b390d07c2/cl-irregsexp-20180202-git/src/force.lisp
; in: DEFUN-CONSISTENT FORCE-SIMPLE-STRING
;     (LENGTH CL-IRREGSEXP::VAL)
; ==>
;   CL-IRREGSEXP::VAL
; 
; note: deleting unreachable code

;     (CL-IRREGSEXP.BYTESTRINGS:FORCE-STRING CL-IRREGSEXP::VAL)
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-STRING-CONSISTENT-INTERNAL BLOCK LET THE 
; --> TYPECASE LET COND IF IF IF IF IF THE PROGN WITH-STANDARD-IO-SYNTAX 
; --> SB-INT:DX-FLET FLET #:THUNK BLOCK 
; ==>
;   (PRINC-TO-STRING CL-IRREGSEXP::VAL)
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a NUMBER.

;     (CL-IRREGSEXP.UTILS:DEFUN-CONSISTENT CL-IRREGSEXP.BYTESTRINGS:FORCE-SIMPLE-STRING
;         (CL-IRREGSEXP::VAL)
;       "Return a representation of VAL as a string, doing the work at compile-time if possible."
;       (DECLARE (OPTIMIZE SPEED (SAFETY 0)))
;       (LET ((CL-IRREGSEXP::VAL
;              (CL-IRREGSEXP.BYTESTRINGS:FORCE-STRING CL-IRREGSEXP::VAL)))
;         (ETYPECASE CL-IRREGSEXP::VAL
;           (SIMPLE-STRING CL-IRREGSEXP::VAL)
;           (STRING (REPLACE # CL-IRREGSEXP::VAL)))))
; --> PROGN CL-IRREGSEXP.UTILS:DEFUN-CAREFUL PROGN DEFUN PROGN SB-IMPL::%DEFUN 
; --> SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-STRING-CONSISTENT-INTERNAL-CAREFUL
;         (CL-IRREGSEXP::VAL)
;       "Return a representation of VAL as a string, doing the work at compile-time if possible."
;       (DECLARE (OPTIMIZE DEBUG SAFETY (SPEED 0)))
;       (DECLARE (OPTIMIZE SPEED (SAFETY 0)))
;       (BLOCK
;           CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-STRING-CONSISTENT-INTERNAL-CAREFUL
;         (LET ((CL-IRREGSEXP::VAL #))
;           (ETYPECASE CL-IRREGSEXP::VAL
;             (SIMPLE-STRING CL-IRREGSEXP::VAL)
;             (STRING #)))))
; 
; caught STYLE-WARNING:
;   Repeated OPTIMIZE qualities. Using (SAFETY 0) and (SPEED 3)

;     (LENGTH CL-IRREGSEXP::VAL)
; ==>
;   CL-IRREGSEXP::VAL
; 
; note: deleting unreachable code

;     (CL-IRREGSEXP.BYTESTRINGS:FORCE-STRING CL-IRREGSEXP::VAL)
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-STRING-CONSISTENT-INTERNAL BLOCK LET THE 
; --> TYPECASE LET COND IF IF IF IF IF THE PROGN WITH-STANDARD-IO-SYNTAX 
; --> SB-INT:DX-FLET FLET #:THUNK BLOCK 
; ==>
;   (PRINC-TO-STRING CL-IRREGSEXP::VAL)
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a NUMBER.

;     (LENGTH CL-IRREGSEXP::VAL)
; ==>
;   CL-IRREGSEXP::VAL
; 
; note: deleting unreachable code

;     (CL-IRREGSEXP.BYTESTRINGS:FORCE-STRING CL-IRREGSEXP::VAL)
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-STRING-CONSISTENT-INTERNAL BLOCK LET THE 
; --> TYPECASE LET COND IF IF IF IF IF THE PROGN WITH-STANDARD-IO-SYNTAX 
; --> SB-INT:DX-FLET FLET #:THUNK BLOCK 
; ==>
;   (PRINC-TO-STRING CL-IRREGSEXP::VAL)
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a NUMBER.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-irregsexp/40dd190eaf28eea03b2208469408590b390d07c2/cl-irregsexp-20180202-git/src/force.lisp
; in: DEFUN-CONSISTENT FORCE-SIMPLE-VECTOR
;     (COPY-SEQ CL-IRREGSEXP::V)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "cl-irregsexp" "src" "force">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-irregsexp/40dd190eaf28eea03b2208469408590b390d07c2/cl-irregsexp-20180202-git/src/harness.lisp
; in:
;      WITH-DEFINE-SPECIALIZED-MATCH-FUNCTIONS (DEFMACRO FORCE-TO-TARGET-SEQUENCE (V) (SB-INT:QUASIQUOTE (FORCE #S(SB-IMPL::COMMA :EXPR V :KIND 0))))
;     (CL-IRREGSEXP::WITH-DEFINE-SPECIALIZED-MATCH-FUNCTIONS
;       (DEFMACRO CL-IRREGSEXP::FORCE-TO-TARGET-SEQUENCE (CL-IRREGSEXP::V)
;         `(CL-IRREGSEXP::FORCE ,CL-IRREGSEXP::V))
;       (DEFMACRO CL-IRREGSEXP::LEN-AVAILABLE ()
;         `(- (LENGTH CL-IRREGSEXP::TARGET) CL-IRREGSEXP::POS))
;       (DEFMACRO CL-IRREGSEXP::CHECK-LEN-AVAILABLE (CL-IRREGSEXP::LEN)
;         (ALEXANDRIA.0.DEV:ONCE-ONLY (CL-IRREGSEXP::LEN)
;           `(LOCALLY
;             (DECLARE #
;                      #)
;             (WHEN # #)
;             (VALUES))))
;       (DEFMACRO CL-IRREGSEXP::PEEK
;                 (&OPTIONAL (CL-IRREGSEXP::LEN '(CL-IRREGSEXP::LEN-AVAILABLE)))
;         (ALEXANDRIA.0.DEV:ONCE-ONLY (CL-IRREGSEXP::LEN)
;           `(LOCALLY
;             (DECLARE #)
;             (CL-IRREGSEXP::CHECK-LEN-AVAILABLE ,CL-IRREGSEXP::LEN)
;             (CL-IRREGSEXP::TARGET-SUBSEQ CL-IRREGSEXP::POS #))))
;       (DEFMACRO CL-IRREGSEXP::EAT (&OPTIONAL (CL-IRREGSEXP::LEN 1))
;         (ALEXANDRIA.0.DEV:ONCE-ONLY (CL-IRREGSEXP::LEN)
;           `(PROG1 (CL-IRREGSEXP::PEEK ,CL-IRREGSEXP::LEN)
;              (CL-IRREGSEXP::EAT-UNCHECKED ,CL-IRREGSEXP::LEN))))
;       (DEFMACRO CL-IRREGSEXP::EAT-UNCHECKED (&OPTIONAL (CL-IRREGSEXP::LEN 1))
;         `(LOCALLY
;           (DECLARE (OPTIMIZE SPEED #)
;                    (TYPE CL-IRREGSEXP::INTEGER-MATCH-INDEX CL-IRREGSEXP::POS))
;           (INCF CL-IRREGSEXP::POS ,CL-IRREGSEXP::LEN)
;           (VALUES)))
;       (DEFMACRO CL-IRREGSEXP::ELT-TARGET (CL-IRREGSEXP::I)
;         (ALEXANDRIA.0.DEV:ONCE-ONLY (CL-IRREGSEXP::I)
;           `(LOCALLY
;             (DECLARE #
;                      #)
;             (ELT CL-IRREGSEXP::TARGET ,CL-IRREGSEXP::I))))
;       (DEFMACRO CL-IRREGSEXP::PEEK-ONE-UNCHECKED (&OPTIONAL (CL-IRREGSEXP::I 0))
;         `(CL-IRREGSEXP::ELT-TARGET (+ CL-IRREGSEXP::POS ,CL-IRREGSEXP::I)))
;       (DEFMACRO CL-IRREGSEXP::PEEK-ONE (&OPTIONAL (CL-IRREGSEXP::I 0))
;         (ALEXANDRIA.0.DEV:ONCE-ONLY (CL-IRREGSEXP::I)
;           `(PROGN
;             (CL-IRREGSEXP::CHECK-LEN-AVAILABLE #)
;             (CL-IRREGSEXP::PEEK-ONE-UNCHECKED ,CL-IRREGSEXP::I))))
;       (CL-IRREGSEXP.UTILS:DEFUN-CONSISTENT CL-IRREGSEXP::FORCE-TO-TARGET-ELEMENT-TYPE
;           (CL-IRREGSEXP::C)
;         (LET ((CL-IRREGSEXP::S #))
;           (ASSERT (= 1 #))
;           (ELT CL-IRREGSEXP::S 0)))
;       (DEFMACRO CL-IRREGSEXP::TARGET-SUBSEQ
;                 (CL-IRREGSEXP::START CL-IRREGSEXP::END)
;         (ALEXANDRIA.0.DEV:ONCE-ONLY (CL-IRREGSEXP::START CL-IRREGSEXP::END)
;           `(LOCALLY
;             (DECLARE #
;                      #)
;             (COND # #))))
;       ...)
; --> PROGN CL-IRREGSEXP::WITH-SPECIALIZED-MATCH-FUNCTIONS PROGN MACROLET 
; --> CL-IRREGSEXP.UTILS:DEFUN-CONSISTENT PROGN CL-IRREGSEXP.UTILS:DEFUN-SPEEDY 
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION BLOCK LET 
; --> CL-IRREGSEXP::FORCE-TO-TARGET-SEQUENCE-SIMPLE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS:FORCE-SIMPLE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL 
; --> BLOCK LET CL-IRREGSEXP.BYTESTRINGS:FORCE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF REPLACE MAKE-ARRAY 
; ==>
;   (LENGTH SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; --> PROGN CL-IRREGSEXP::WITH-SPECIALIZED-MATCH-FUNCTIONS PROGN MACROLET 
; --> CL-IRREGSEXP.UTILS:DEFUN-CONSISTENT PROGN CL-IRREGSEXP.UTILS:DEFUN-SPEEDY 
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION BLOCK LET 
; --> CL-IRREGSEXP::FORCE-TO-TARGET-SEQUENCE-SIMPLE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS:FORCE-SIMPLE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL 
; --> BLOCK LET CL-IRREGSEXP.BYTESTRINGS:FORCE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF 
; ==>
;   (REPLACE (MAKE-ARRAY (LENGTH SB-C::X) :ELEMENT-TYPE '(UNSIGNED-BYTE 8))
;            SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).

; --> PROGN CL-IRREGSEXP::WITH-SPECIALIZED-MATCH-FUNCTIONS PROGN MACROLET 
; --> CL-IRREGSEXP.UTILS:DEFUN-CONSISTENT PROGN 
; --> CL-IRREGSEXP.UTILS:DEFUN-CAREFUL PROGN DEFUN PROGN SB-IMPL::%DEFUN 
; --> SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION MULTIPLE-VALUE-PROG1 PROGN 
; --> BLOCK LET CL-IRREGSEXP::FORCE-TO-TARGET-SEQUENCE-SIMPLE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS:FORCE-SIMPLE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL 
; --> BLOCK LET CL-IRREGSEXP.BYTESTRINGS:FORCE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF REPLACE MAKE-ARRAY 
; ==>
;   (LENGTH SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; --> PROGN CL-IRREGSEXP::WITH-SPECIALIZED-MATCH-FUNCTIONS PROGN MACROLET 
; --> CL-IRREGSEXP.UTILS:DEFUN-CONSISTENT PROGN 
; --> CL-IRREGSEXP.UTILS:DEFUN-CAREFUL PROGN DEFUN PROGN SB-IMPL::%DEFUN 
; --> SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION MULTIPLE-VALUE-PROG1 PROGN 
; --> BLOCK LET CL-IRREGSEXP::FORCE-TO-TARGET-SEQUENCE-SIMPLE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS:FORCE-SIMPLE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL 
; --> BLOCK LET CL-IRREGSEXP.BYTESTRINGS:FORCE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF 
; ==>
;   (REPLACE (MAKE-ARRAY (LENGTH SB-C::X) :ELEMENT-TYPE '(UNSIGNED-BYTE 8))
;            SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).

; --> PROGN CL-IRREGSEXP::WITH-SPECIALIZED-MATCH-FUNCTIONS PROGN MACROLET 
; --> CL-IRREGSEXP.UTILS:DEFUN-CONSISTENT PROGN DEFUN PROGN SB-IMPL::%DEFUN 
; --> SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> CL-IRREGSEXP::FORCE-TO-TARGET-ELEMENT-TYPE-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL 
; --> BLOCK LET CL-IRREGSEXP::FORCE-TO-TARGET-SEQUENCE-SIMPLE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS:FORCE-SIMPLE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL 
; --> BLOCK LET CL-IRREGSEXP.BYTESTRINGS:FORCE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF REPLACE MAKE-ARRAY 
; ==>
;   (LENGTH SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; --> PROGN CL-IRREGSEXP::WITH-SPECIALIZED-MATCH-FUNCTIONS PROGN MACROLET 
; --> CL-IRREGSEXP.UTILS:DEFUN-CONSISTENT PROGN DEFUN PROGN SB-IMPL::%DEFUN 
; --> SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> CL-IRREGSEXP::FORCE-TO-TARGET-ELEMENT-TYPE-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL 
; --> BLOCK LET CL-IRREGSEXP::FORCE-TO-TARGET-SEQUENCE-SIMPLE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS:FORCE-SIMPLE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL 
; --> BLOCK LET CL-IRREGSEXP.BYTESTRINGS:FORCE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF 
; ==>
;   (REPLACE (MAKE-ARRAY (LENGTH SB-C::X) :ELEMENT-TYPE '(UNSIGNED-BYTE 8))
;            SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).

; --> PROGN CL-IRREGSEXP::WITH-SPECIALIZED-MATCH-FUNCTIONS PROGN MACROLET 
; --> CL-IRREGSEXP.UTILS:DEFUN-CONSISTENT PROGN CL-IRREGSEXP.UTILS:DEFUN-SPEEDY 
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION BLOCK LET CL-IRREGSEXP::FORCE-TO-TARGET-SEQUENCE-SIMPLE-STRING 
; --> CL-IRREGSEXP.BYTESTRINGS:FORCE-SIMPLE-STRING 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-STRING-CONSISTENT-INTERNAL BLOCK 
; --> LET CL-IRREGSEXP.BYTESTRINGS:FORCE-STRING 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-STRING-CONSISTENT-INTERNAL BLOCK LET THE 
; --> TYPECASE LET COND IF IF IF IF IF THE PROGN WITH-STANDARD-IO-SYNTAX 
; --> SB-INT:DX-FLET FLET #:THUNK BLOCK 
; ==>
;   (PRINC-TO-STRING CL-IRREGSEXP::VAL)
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a NUMBER.

; --> PROGN CL-IRREGSEXP::WITH-SPECIALIZED-MATCH-FUNCTIONS PROGN MACROLET 
; --> CL-IRREGSEXP.UTILS:DEFUN-CONSISTENT PROGN 
; --> CL-IRREGSEXP.UTILS:DEFUN-CAREFUL PROGN DEFUN PROGN SB-IMPL::%DEFUN 
; --> SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION MULTIPLE-VALUE-PROG1 PROGN 
; --> BLOCK LET CL-IRREGSEXP::FORCE-TO-TARGET-SEQUENCE-SIMPLE-STRING 
; --> CL-IRREGSEXP.BYTESTRINGS:FORCE-SIMPLE-STRING 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-STRING-CONSISTENT-INTERNAL BLOCK 
; --> LET CL-IRREGSEXP.BYTESTRINGS:FORCE-STRING 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-STRING-CONSISTENT-INTERNAL BLOCK LET THE 
; --> TYPECASE LET COND IF IF IF IF IF THE PROGN WITH-STANDARD-IO-SYNTAX 
; --> SB-INT:DX-FLET FLET #:THUNK BLOCK 
; ==>
;   (PRINC-TO-STRING CL-IRREGSEXP::VAL)
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a NUMBER.

; --> PROGN CL-IRREGSEXP::WITH-SPECIALIZED-MATCH-FUNCTIONS PROGN MACROLET 
; --> CL-IRREGSEXP.UTILS:DEFUN-CONSISTENT PROGN DEFUN PROGN SB-IMPL::%DEFUN 
; --> SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> CL-IRREGSEXP::FORCE-TO-TARGET-ELEMENT-TYPE-SIMPLE-STRING-CONSISTENT-INTERNAL 
; --> BLOCK LET CL-IRREGSEXP::FORCE-TO-TARGET-SEQUENCE-SIMPLE-STRING 
; --> CL-IRREGSEXP.BYTESTRINGS:FORCE-SIMPLE-STRING 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-STRING-CONSISTENT-INTERNAL BLOCK 
; --> LET CL-IRREGSEXP.BYTESTRINGS:FORCE-STRING 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-STRING-CONSISTENT-INTERNAL BLOCK LET THE 
; --> TYPECASE LET COND IF IF IF IF IF THE PROGN WITH-STANDARD-IO-SYNTAX 
; --> SB-INT:DX-FLET FLET #:THUNK BLOCK 
; ==>
;   (PRINC-TO-STRING CL-IRREGSEXP::VAL)
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a NUMBER.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-irregsexp/40dd190eaf28eea03b2208469408590b390d07c2/cl-irregsexp-20180202-git/src/helpers.lisp
; in: DEFSIMPLIFIER LITERAL
;     (CL-IRREGSEXP::DEFSIMPLIFIER CL-IRREGSEXP::LITERAL
;         (CL-IRREGSEXP::VALUE)
;       (COND
;        ((CONSTANTP CL-IRREGSEXP::VALUE)
;         (CL-IRREGSEXP::MAKE-CONST :VALUE
;                                   (CL-IRREGSEXP::FORCE-TO-TARGET-SEQUENCE #)))
;        (T `(CL-IRREGSEXP::DYNAMIC-LITERAL ,CL-IRREGSEXP::VALUE))))
; --> CL-IRREGSEXP::WITH-DEFINE-SPECIALIZED-MATCH-FUNCTIONS PROGN 
; --> CL-IRREGSEXP::WITH-SPECIALIZED-MATCH-FUNCTIONS PROGN MACROLET 
; --> CL-IRREGSEXP::DEFSIMPLIFIER-GO PROGN EVAL-WHEN SETF LET* LET* 
; --> CL-IRREGSEXP::MAKE-SIMPLIFIER LAMBDA FUNCTION DESTRUCTURING-BIND 
; --> SB-INT:BINDING* LET* COND IF CL-IRREGSEXP::MAKE-CONST 
; --> CL-IRREGSEXP::FORCE-TO-TARGET-SEQUENCE-SIMPLE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS:FORCE-SIMPLE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL 
; --> BLOCK LET CL-IRREGSEXP.BYTESTRINGS:FORCE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF REPLACE MAKE-ARRAY 
; ==>
;   (LENGTH SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; --> CL-IRREGSEXP::WITH-DEFINE-SPECIALIZED-MATCH-FUNCTIONS PROGN 
; --> CL-IRREGSEXP::WITH-SPECIALIZED-MATCH-FUNCTIONS PROGN MACROLET 
; --> CL-IRREGSEXP::DEFSIMPLIFIER-GO PROGN EVAL-WHEN SETF LET* LET* 
; --> CL-IRREGSEXP::MAKE-SIMPLIFIER LAMBDA FUNCTION DESTRUCTURING-BIND 
; --> SB-INT:BINDING* LET* COND IF CL-IRREGSEXP::MAKE-CONST 
; --> CL-IRREGSEXP::FORCE-TO-TARGET-SEQUENCE-SIMPLE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS:FORCE-SIMPLE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-BYTE-VECTOR-CONSISTENT-INTERNAL 
; --> BLOCK LET CL-IRREGSEXP.BYTESTRINGS:FORCE-BYTE-VECTOR 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-BYTE-VECTOR-CONSISTENT-INTERNAL BLOCK 
; --> TYPECASE LET COND IF IF IF IF IF PROGN COERCE THE IF 
; ==>
;   (REPLACE (MAKE-ARRAY (LENGTH SB-C::X) :ELEMENT-TYPE '(UNSIGNED-BYTE 8))
;            SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR CONS NULL (AND (NOT BASE-STRING) (NOT (VECTOR NIL)) (NOT (VECTOR CHARACTER)) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).

; --> CL-IRREGSEXP::WITH-DEFINE-SPECIALIZED-MATCH-FUNCTIONS PROGN 
; --> CL-IRREGSEXP::WITH-SPECIALIZED-MATCH-FUNCTIONS PROGN MACROLET 
; --> CL-IRREGSEXP::DEFSIMPLIFIER-GO PROGN EVAL-WHEN SETF LET* LET* 
; --> CL-IRREGSEXP::MAKE-SIMPLIFIER LAMBDA FUNCTION DESTRUCTURING-BIND 
; --> SB-INT:BINDING* LET* COND IF CL-IRREGSEXP::MAKE-CONST 
; --> CL-IRREGSEXP::FORCE-TO-TARGET-SEQUENCE-SIMPLE-STRING 
; --> CL-IRREGSEXP.BYTESTRINGS:FORCE-SIMPLE-STRING 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-SIMPLE-STRING-CONSISTENT-INTERNAL BLOCK 
; --> LET CL-IRREGSEXP.BYTESTRINGS:FORCE-STRING 
; --> CL-IRREGSEXP.BYTESTRINGS::FORCE-STRING-CONSISTENT-INTERNAL BLOCK LET THE 
; --> TYPECASE LET COND IF IF IF IF IF THE PROGN WITH-STANDARD-IO-SYNTAX 
; --> SB-INT:DX-FLET FLET #:THUNK BLOCK 
; ==>
;   (PRINC-TO-STRING CL-IRREGSEXP::VAL)
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a NUMBER.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-irregsexp/40dd190eaf28eea03b2208469408590b390d07c2/cl-irregsexp-20180202-git/src/replace.lisp
; in: DEFUN REPLACE-CONCATENATE-SEQUENCES
;     (AREF CL-IRREGSEXP::SEQUENCES 0)
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

;     (CL-IRREGSEXP::GEN CL-IRREGSEXP.BYTESTRINGS:BYTE-VECTOR STRING)
; --> ETYPECASE LET COND IF PROGN LOOP BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ 
; --> SETQ THE AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not