org-davep-nntp on sbcl-0.9.9-darwin-ppc - Details

Author:Dave Pearson <davep@davep.org>
Version:2.0
Description:Simple NNTP client for Common Lisp.
Started at:2006-04-16 01:33:43
Ended at:2006-04-16 01:35:02
Elapsed time (seconds):79
Depends On:split-sequence, acl-compat
Error:erred while invoking #<COMPILE-OP NIL {40007F59}> on #<UNPORTABLE-CL-SOURCE-FILE \"acl-mp\" {40007F69}>
Most recent change:2004-06-22 09:38:10
Most recent file:/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/org-davep-nntp-2.0/nntp.lisp

REPL Output

;;; ASDF-INSTALL: Downloading 5155 bytes from http://www.davep.org/lisp/org-davep-nntp-2.0.tar.gz to /Users/gwking/temporary/asdf-test/ORG-DAVEP-NNTP.asdf-install-tmp ...

;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/ORG-DAVEP-NNTP.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
org-davep-nntp-2.0/
org-davep-nntp-2.0/packages.lisp
org-davep-nntp-2.0/nntp.lisp
org-davep-nntp-2.0/org-davep-nntp.asd

#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/org-davep-nntp-2.0/" 
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/org-davep-nntp-2.0/" ;;; ASDF-INSTALL: Downloading package ACL-COMPAT, required by org-davep-nntp

;;; ASDF-INSTALL: Downloading 55164 bytes from http://constantly.at/lisp/acl-compat.tar.gz to /Users/gwking/temporary/asdf-test/acl-compat.asdf-install-tmp ...

;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/acl-compat.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
acl-compat/
acl-compat/acl-compat-cmu.system
acl-compat/acl-compat-common-lisp-lw.lisp
acl-compat/acl-compat-corman.lisp
acl-compat/acl-compat.asd
acl-compat/acl-excl-common.lisp
acl-compat/acl-excl-corman.lisp
acl-compat/acl-mp-corman.lisp
acl-compat/acl-mp-package.lisp
acl-compat/acl-socket-corman.lisp
acl-compat/acl-ssl-streams.lisp
acl-compat/acl-ssl.lisp
acl-compat/allegro/
acl-compat/allegro/acl-excl.lisp
acl-compat/allegro/acl-mp.lisp
acl-compat/allegro/acl-socket.lisp
acl-compat/allegro/acl-sys.lisp
acl-compat/ChangeLog
acl-compat/chunked-stream-mixin.lisp
acl-compat/chunked.lisp
acl-compat/clisp/
acl-compat/clisp/acl-excl.lisp
acl-compat/clisp/acl-mp.lisp
acl-compat/clisp/acl-socket.lisp
acl-compat/clisp/acl-sys.lisp
acl-compat/cmucl/
acl-compat/cmucl/acl-excl.lisp
acl-compat/cmucl/acl-mp.lisp
acl-compat/cmucl/acl-socket.lisp
acl-compat/cmucl/acl-sys.lisp
acl-compat/CREDITS
acl-compat/defsys.lisp
acl-compat/lispworks/
acl-compat/lispworks/acl-excl.lisp
acl-compat/lispworks/acl-mp.lisp
acl-compat/lispworks/acl-socket.lisp
acl-compat/lispworks/acl-sys.lisp
acl-compat/lw-buffering.lisp
acl-compat/mcl/
acl-compat/mcl/acl-excl.lisp
acl-compat/mcl/acl-mp.lisp
acl-compat/mcl/acl-socket-mcl.lisp
acl-compat/mcl/acl-socket-openmcl.lisp
acl-compat/mcl/acl-sys.lisp
acl-compat/mcl/mcl-stream-fix.lisp
acl-compat/mcl/mcl-timers.lisp
acl-compat/packages.lisp
acl-compat/README
acl-compat/sbcl/
acl-compat/sbcl/acl-excl.lisp
acl-compat/sbcl/acl-mp.lisp
acl-compat/sbcl/acl-socket.lisp
acl-compat/sbcl/acl-sys.lisp
acl-compat/scl/
acl-compat/scl/acl-excl.lisp
acl-compat/scl/acl-mp.lisp
acl-compat/scl/acl-socket.lisp
acl-compat/scl/acl-sys.lisp
acl-compat/test-acl-socket.lisp

#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/" 
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/" ;;; ASDF-INSTALL: Downloading package CL-PPCRE, required by acl-compat

;;; ASDF-INSTALL: Downloading 166573 bytes from http://weitz.de/files/cl-ppcre.tar.gz to /Users/gwking/temporary/asdf-test/cl-ppcre.asdf-install-tmp ...

;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/cl-ppcre.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
cl-ppcre-1.2.13/
cl-ppcre-1.2.13/doc/
cl-ppcre-1.2.13/doc/benchmarks.2002-12-22.txt
cl-ppcre-1.2.13/doc/index.html
cl-ppcre-1.2.13/CHANGELOG
cl-ppcre-1.2.13/README
cl-ppcre-1.2.13/api.lisp
cl-ppcre-1.2.13/cl-ppcre-test.asd
cl-ppcre-1.2.13/cl-ppcre-test.system
cl-ppcre-1.2.13/cl-ppcre.asd
cl-ppcre-1.2.13/cl-ppcre.system
cl-ppcre-1.2.13/closures.lisp
cl-ppcre-1.2.13/convert.lisp
cl-ppcre-1.2.13/errors.lisp
cl-ppcre-1.2.13/lexer.lisp
cl-ppcre-1.2.13/lispworks-defsystem.lisp
cl-ppcre-1.2.13/load.lisp
cl-ppcre-1.2.13/optimize.lisp
cl-ppcre-1.2.13/packages.lisp
cl-ppcre-1.2.13/parser.lisp
cl-ppcre-1.2.13/perltest.pl
cl-ppcre-1.2.13/ppcre-tests.lisp
cl-ppcre-1.2.13/regex-class.lisp
cl-ppcre-1.2.13/repetition-closures.lisp
cl-ppcre-1.2.13/scanner.lisp
cl-ppcre-1.2.13/specials.lisp
cl-ppcre-1.2.13/testdata
cl-ppcre-1.2.13/testinput
cl-ppcre-1.2.13/util.lisp

#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/" 
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/" 
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/packages.lisp" (written 01 APR 2005 04:29:10 PM):
; compiling (IN-PACKAGE :CL-USER)
; compiling (DEFPACKAGE #:CL-PPCRE ...)
; compiling (DEFPACKAGE #:CL-PPCRE-TEST ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/packages.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/specials.lisp" (written 01 APR 2005 04:29:10 PM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFVAR *STANDARD-OPTIMIZE-SETTINGS* ...)
; compiling (DEFVAR *SPECIAL-OPTIMIZE-SETTINGS* ...)
; compiling (DEFVAR *EXTENDED-MODE-P* ...)
; compiling (DECLAIM (TYPE BOOLEAN ...))
; compiling (DEFVAR *STRING* ...)
; compiling (DECLAIM (TYPE SIMPLE-STRING ...))
; compiling (DEFVAR *START-POS* ...)
; compiling (DECLAIM (TYPE FIXNUM ...))
; compiling (DEFVAR *REAL-START-POS* ...)
; compiling (DECLAIM (TYPE # ...))
; compiling (DEFVAR *END-POS* ...)
; compiling (DECLAIM (TYPE FIXNUM ...))
; compiling (DEFVAR *REG-STARTS* ...)
; compiling (DECLAIM (TYPE SIMPLE-VECTOR ...))
; compiling (DEFVAR *REGS-MAYBE-START* ...)
; compiling (DECLAIM (TYPE SIMPLE-VECTOR ...))
; compiling (DEFVAR *REG-ENDS* ...)
; compiling (DECLAIM (TYPE SIMPLE-VECTOR ...))
; compiling (DEFVAR *END-STRING-POS* ...)
; compiling (DEFVAR *REP-NUM* ...)
; compiling (DECLAIM (TYPE FIXNUM ...))
; compiling (DEFVAR *ZERO-LENGTH-NUM* ...)
; compiling (DECLAIM (TYPE FIXNUM ...))
; compiling (DEFVAR *REPEAT-COUNTERS* ...)
; compiling (DECLAIM (TYPE # ...))
; compiling (DEFVAR *LAST-POS-STORES* ...)
; compiling (DECLAIM (TYPE SIMPLE-VECTOR ...))
; compiling (DEFVAR *USE-BMH-MATCHERS* ...)
; compiling (DEFVAR *ALLOW-QUOTING* ...)
; compiling (PUSHNEW :CL-PPCRE ...)
; compiling (DEFVAR *HYPERDOC-BASE-URI* ...)
; compiling (LET (#) ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/specials.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/util.lisp" (written 23 AUG 2005 06:32:30 AM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFMACRO WITH-UNIQUE-NAMES ...)
; compiling (DEFMACRO WITH-REBINDING ...)
; compiling (DEFVAR *REGEX-CHAR-CODE-LIMIT* ...)
; compiling (DECLAIM (TYPE FIXNUM ...))
; compiling (DEFUN MAKE-CHAR-HASH ...); in: LAMBDA NIL
;     (FUNCALL CL-PPCRE::TEST CL-PPCRE::CHR)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
;   The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/util.lisp
; in: DEFUN MAKE-CHAR-HASH
;     (FUNCALL CL-PPCRE::TEST CL-PPCRE::CHR)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
;   The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.

; compiling (DECLAIM (INLINE WORD-CHAR-P))
; compiling (DEFUN WORD-CHAR-P ...); in: LAMBDA NIL
;     (ALPHANUMERICP CL-PPCRE::CHR)
; --> BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

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

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/util.lisp
; in: DEFUN WORD-CHAR-P
;     (ALPHANUMERICP CL-PPCRE::CHR)
; --> BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

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

; compiling (UNLESS (BOUNDP #) ...)
; compiling (DEFUN WHITESPACEP ...)
; compiling (UNLESS (BOUNDP #) ...)
; compiling (UNLESS (BOUNDP #) ...)
; compiling (UNLESS (BOUNDP #) ...)
; compiling (DEFUN MERGE-HASH ...)
; compiling (DEFUN MERGE-INVERTED-HASH ...)
; compiling (DEFUN CREATE-RANGES-FROM-HASH ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/util.lisp
; in: DEFUN CREATE-RANGES-FROM-HASH
;     (CHAR-DOWNCASE CL-PPCRE::CHR)
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.

; compiling (DEFMACRO MAYBE-COERCE-TO-SIMPLE-STRING ...)
; compiling (DECLAIM (INLINE NSUBSEQ))
; compiling (DEFUN NSUBSEQ ...)
; compiling (DEFUN NORMALIZE-VAR-LIST ...)
; compiling (DEFUN STRING-LIST-TO-SIMPLE-STRING ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/util.lisp
; in: DEFUN STRING-LIST-TO-SIMPLE-STRING
;     (REPLACE CL-PPCRE::RESULT-STRING STRING :START1 CL-PPCRE::CURR-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a STRING, not a (SIMPLE-ARRAY CHARACTER (*)).

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/util.fasl written
; compilation finished in 0:00:01
STYLE-WARNING: redefining MAKE-CHAR-HASH in DEFUN
STYLE-WARNING: redefining WORD-CHAR-P in DEFUN
STYLE-WARNING: redefining WHITESPACEP in DEFUN
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/errors.lisp" (written 01 APR 2005 04:29:09 PM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFVAR *SYNTAX-ERROR-STRING* ...)
; compiling (DEFINE-CONDITION PPCRE-ERROR ...)
; compiling (DEFINE-CONDITION PPCRE-SYNTAX-ERROR ...)
; compiling (SETF (DOCUMENTATION # ...) ...)
; compiling (SETF (DOCUMENTATION # ...) ...)
; compiling (DEFINE-CONDITION PPCRE-INVOCATION-ERROR ...)
; compiling (DEFMACRO SIGNAL-PPCRE-SYNTAX-ERROR* ...)
; compiling (DEFMACRO SIGNAL-PPCRE-SYNTAX-ERROR ...)
; compiling (DEFMACRO SIGNAL-PPCRE-INVOCATION-ERROR ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/errors.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/lexer.lisp" (written 01 APR 2005 04:29:09 PM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DECLAIM (INLINE MAP-CHAR-TO-SPECIAL-CLASS))
; compiling (DEFUN MAP-CHAR-TO-SPECIAL-CHAR-CLASS ...)
; compiling (DEFSTRUCT (LEXER #) ...)
; compiling (DEFUN MAKE-LEXER ...)
; compiling (DECLAIM (INLINE END-OF-STRING-P))
; compiling (DEFUN END-OF-STRING-P ...)
; compiling (DECLAIM (INLINE LOOKING-AT-P))
; compiling (DEFUN LOOKING-AT-P ...)
; compiling (DECLAIM (INLINE NEXT-CHAR-NON-EXTENDED))
; compiling (DEFUN NEXT-CHAR-NON-EXTENDED ...)
; compiling (DEFUN NEXT-CHAR ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/lexer.lisp
; in: DEFUN NEXT-CHAR
;     (CL-PPCRE::SIGNAL-PPCRE-SYNTAX-ERROR* CL-PPCRE::ERROR-POS
;                                         "Comment group not closed")
; ==>
;   (ERROR 'CL-PPCRE:PPCRE-SYNTAX-ERROR
;          :POS
;          CL-PPCRE::ERROR-POS
;          :FORMAT-CONTROL
;          "Comment group not closed"
;          :FORMAT-ARGUMENTS
;          (LIST))
; 
; note: doing signed word to integer coercion (cost 20)

; compiling (DECLAIM (INLINE FAIL))
; compiling (DEFUN FAIL ...)
; compiling (DEFUN GET-NUMBER ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/lexer.lisp
; in: DEFUN GET-NUMBER
;     (IF (< CL-PPCRE::END-POS CL-PPCRE::LEXER-LEN)
;       CL-PPCRE::END-POS
;       CL-PPCRE::LEXER-LEN)
; ==>
;   CL-PPCRE::END-POS
; 
; note: doing signed word to integer coercion (cost 20)

; compiling (DECLAIM (INLINE TRY-NUMBER))
; compiling (DEFUN TRY-NUMBER ...)
; compiling (DECLAIM (INLINE MAKE-CHAR-FROM-CODE))
; compiling (DEFUN MAKE-CHAR-FROM-CODE ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/lexer.lisp
; in: DEFUN MAKE-CHAR-FROM-CODE
;     (CL-PPCRE::SIGNAL-PPCRE-SYNTAX-ERROR* CL-PPCRE::ERROR-POS
;                                         "No character for hex-code ~X"
;                                         NUMBER)
; --> ERROR 
; ==>
;   CL-PPCRE::ERROR-POS
; 
; note: deleting unreachable code

; compiling (DEFUN UNESCAPE-CHAR ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/lexer.lisp
; in: DEFUN MAKE-CHAR-FROM-CODE
;     (CL-PPCRE::SIGNAL-PPCRE-SYNTAX-ERROR* CL-PPCRE::ERROR-POS
;                                         "No character for hex-code ~X"
;                                         NUMBER)
; --> ERROR 
; ==>
;   "No character for hex-code ~X"
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

; in: DEFUN UNESCAPE-CHAR
;     (CHAR-UPCASE CL-PPCRE::NEXT-CHAR)
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.

; compiling (DEFUN COLLECT-CHAR-CLASS ...)
; compiling (DEFUN MAYBE-PARSE-FLAGS ...)
; compiling (DEFUN GET-QUANTIFIER ...)
; compiling (DEFUN GET-TOKEN ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/lexer.lisp
; in: DEFUN MAKE-CHAR-FROM-CODE
;     (CL-PPCRE::SIGNAL-PPCRE-SYNTAX-ERROR* CL-PPCRE::ERROR-POS
;                                         "No character for hex-code ~X"
;                                         NUMBER)
; --> ERROR 
; ==>
;   "No character for hex-code ~X"
; 
; note: deleting unreachable code

; ==>
;   CL-PPCRE::ERROR-POS
; 
; note: deleting unreachable code

; in: DEFUN GET-TOKEN
;     (SUBSEQ (CL-PPCRE::LEXER-STR CL-PPCRE::LEXER)
;           (CAR CL-PPCRE::THIS-LAST-POS)
;           (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-BASE-STRING.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY CHARACTER (*))
;                                              &REST
;                                              T).

;     (SUBSEQ (CL-PPCRE::LEXER-STR CL-PPCRE::LEXER)
;           (CAR (CL-PPCRE::LEXER-LAST-POS CL-PPCRE::LEXER))
;           (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-BASE-STRING.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY CHARACTER (*))
;                                              &REST
;                                              T).

;     (CL-PPCRE::SIGNAL-PPCRE-SYNTAX-ERROR*
;    (1- (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER))
;    "Character '~A' may not follow '(?<'"
;    CL-PPCRE::NEXT-CHAR)
; ==>
;   (ERROR 'CL-PPCRE:PPCRE-SYNTAX-ERROR
;          :POS
;          (1- (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER))
;          :FORMAT-CONTROL
;          "Character '~A' may not follow '(?<'"
;          :FORMAT-ARGUMENTS
;          (LIST CL-PPCRE::NEXT-CHAR))
; 
; note: doing signed word to integer coercion (cost 20)

;     (CL-PPCRE::SIGNAL-PPCRE-SYNTAX-ERROR*
;    (1- (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER))
;    "Character '~A' may not follow '(?'"
;    CL-PPCRE::NEXT-CHAR)
; ==>
;   (ERROR 'CL-PPCRE:PPCRE-SYNTAX-ERROR
;          :POS
;          (1- (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER))
;          :FORMAT-CONTROL
;          "Character '~A' may not follow '(?'"
;          :FORMAT-ARGUMENTS
;          (LIST CL-PPCRE::NEXT-CHAR))
; 
; note: doing signed word to integer coercion (cost 20)

;     (CL-PPCRE::SIGNAL-PPCRE-SYNTAX-ERROR*
;    (1- (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER))
;    "Quantifier '~A' not allowed"
;    CL-PPCRE::NEXT-CHAR)
; ==>
;   (ERROR 'CL-PPCRE:PPCRE-SYNTAX-ERROR
;          :POS
;          (1- (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER))
;          :FORMAT-CONTROL
;          "Quantifier '~A' not allowed"
;          :FORMAT-ARGUMENTS
;          (LIST CL-PPCRE::NEXT-CHAR))
; 
; note: doing signed word to integer coercion (cost 20)

; compiling (DECLAIM (INLINE UNGET-TOKEN))
; compiling (DEFUN UNGET-TOKEN ...)
; compiling (DECLAIM (INLINE START-OF-SUBEXPR-P))
; compiling (DEFUN START-OF-SUBEXPR-P ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/lexer.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/parser.lisp" (written 03 AUG 2005 05:11:27 PM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFUN GROUP ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/parser.lisp
; in: DEFUN GROUP
;     (CL-PPCRE::SIGNAL-PPCRE-SYNTAX-ERROR* (+ CL-PPCRE::OPEN-PAREN-POS 2)
;                                         "Opening paren has no matching closing paren")
; ==>
;   (ERROR 'CL-PPCRE:PPCRE-SYNTAX-ERROR
;          :POS
;          (+ CL-PPCRE::OPEN-PAREN-POS 2)
;          :FORMAT-CONTROL
;          "Opening paren has no matching closing paren"
;          :FORMAT-ARGUMENTS
;          (LIST))
; 
; note: doing signed word to integer coercion (cost 20)

; compiling (DEFUN GREEDY-QUANT ...)
; compiling (DEFUN QUANT ...)
; compiling (DEFUN SEQ ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/parser.lisp
; in: DEFUN SEQ
;     (SETF (AREF STRING 0) CL-PPCRE::CHAR1)
; --> SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR CHARACTER), not a SIMPLE-ARRAY.

;     (SETF (AREF STRING 1) CL-PPCRE::CHAR2)
; --> SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR CHARACTER), not a SIMPLE-ARRAY.

;     (CL-PPCRE::START-OF-SUBEXPR-P CL-PPCRE::LEXER)
; --> BLOCK LET* NOT IF OR LET IF OR PROG1 LET MEMBER BLOCK LET AND IF AND 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::KEY)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
;   The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.

; --> BLOCK LET* NOT IF OR LET IF OR PROG1 LET MEMBER BLOCK LET IF 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::TEST)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
;   The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.

; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::TEST-NOT)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
;   The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.

; compiling (DEFUN REG-EXPR ...)
; compiling (DEFUN REVERSE-STRINGS ...)
; compiling (DEFUN PARSE-STRING ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/parser.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/regex-class.lisp" (written 10 JUN 2005 06:23:42 AM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFCLASS REGEX ...)
; compiling (DEFCLASS SEQ ...)
; compiling (DEFCLASS ALTERNATION ...)
; compiling (DEFCLASS LOOKAHEAD ...)
; compiling (DEFCLASS LOOKBEHIND ...)
; compiling (DEFCLASS REPETITION ...)
; compiling (DEFCLASS REGISTER ...)
; compiling (DEFCLASS STANDALONE ...)
; compiling (DEFCLASS BACK-REFERENCE ...)
; compiling (DEFCLASS CHAR-CLASS ...)
; compiling (DEFCLASS STR ...)
; compiling (DEFCLASS ANCHOR ...)
; compiling (DEFCLASS EVERYTHING ...)
; compiling (DEFCLASS WORD-BOUNDARY ...)
; compiling (DEFCLASS BRANCH ...)
; compiling (DEFCLASS FILTER ...)
; compiling (DEFCLASS VOID ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/regex-class.lisp
; in: DEFMETHOD INITIALIZE-INSTANCE :AFTER (CHAR-CLASS)
;     (> (HASH-TABLE-COUNT CL-PPCRE::HASH) (/ CL-PPCRE:*REGEX-CHAR-CODE-LIMIT* 2))
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a (RATIONAL -268435456 536870911/2), not a FIXNUM.

; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/regex-class.lisp
; in: DEFMETHOD INITIALIZE-INSTANCE :AFTER (STR)
;     (LENGTH (CL-PPCRE::STR CL-PPCRE::STR))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; compiling (DEFMETHOD LEN ...)
; compiling (DEFMETHOD STR ...)
; compiling (DEFMETHOD SKIP ...)
; compiling (DEFMETHOD START-OF-END-STRING-P ...)
; compiling (DEFGENERIC CASE-MODE ...)
; compiling (DEFMETHOD CASE-MODE ...)
; compiling (DEFMETHOD CASE-MODE ...)
; compiling (DEFGENERIC COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFMETHOD COPY-REGEX ...)
; compiling (DEFGENERIC REMOVE-REGISTERS ...)
; compiling (DEFMETHOD REMOVE-REGISTERS ...)
; compiling (DEFMETHOD REMOVE-REGISTERS ...)
; compiling (DEFMETHOD REMOVE-REGISTERS ...)
; compiling (DEFMETHOD REMOVE-REGISTERS ...)
; compiling (DEFMETHOD REMOVE-REGISTERS ...)
; compiling (DEFMETHOD REMOVE-REGISTERS ...)
; compiling (DEFMETHOD REMOVE-REGISTERS ...)
; compiling (DEFMETHOD REMOVE-REGISTERS ...)
; compiling (DEFMETHOD REMOVE-REGISTERS ...)
; compiling (DEFGENERIC EVERYTHINGP ...)
; compiling (DEFMETHOD EVERYTHINGP ...)
; compiling (DEFMETHOD EVERYTHINGP ...)
; compiling (DEFMETHOD EVERYTHINGP ...)
; compiling (DEFMETHOD EVERYTHINGP ...)
; compiling (DEFMETHOD EVERYTHINGP ...)
; compiling (DEFMETHOD EVERYTHINGP ...)
; compiling (DEFMETHOD EVERYTHINGP ...)
; compiling (DEFGENERIC REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFMETHOD REGEX-LENGTH ...)
; compiling (DEFGENERIC REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFMETHOD REGEX-MIN-LENGTH ...)
; compiling (DEFGENERIC COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)
; compiling (DEFMETHOD COMPUTE-OFFSETS ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/regex-class.fasl written
; compilation finished in 0:00:08
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/convert.lisp" (written 01 APR 2005 04:29:09 PM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFMACRO CASE-INSENSITIVE-MODE-P ...)
; compiling (DEFMACRO MULTI-LINE-MODE-P ...)
; compiling (DEFMACRO SINGLE-LINE-MODE-P ...)
; compiling (DEFUN SET-FLAG ...)
; compiling (DEFUN ADD-RANGE-TO-HASH ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/convert.lisp
; in: DEFUN ADD-RANGE-TO-HASH
;     (CHAR-UPCASE CL-PPCRE::CHR)
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.

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

; compiling (DEFUN CONVERT-CHAR-CLASS-TO-HASH ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/convert.lisp
; in: DEFUN CONVERT-CHAR-CLASS-TO-HASH
;     (CEILING (EXPT CL-PPCRE:*REGEX-CHAR-CODE-LIMIT* (/ 1 4)))
; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET VALUES 
; ==>
;   (- SB-C::X SB-C::RES)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR SINGLE-FLOAT RATIONAL), not a FLOAT.

; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF 
; --> NOT IF ZEROP 
; ==>
;   (= REM 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR RATIONAL SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF 
; --> AND IF PLUSP 
; ==>
;   (> NUMBER 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR SINGLE-FLOAT RATIONAL), not a FLOAT.

; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET 
; ==>
;   (SB-KERNEL:%UNARY-TRUNCATE SB-C::X)
; 
; note: forced to do full call
;       unable to do inline float truncate (cost 5) because:
;       The first argument is a (OR SINGLE-FLOAT RATIONAL), not a SINGLE-FLOAT.
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
;                                                         &REST
;                                                         T).

; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET VALUES 
; ==>
;   (- SB-C::X SB-C::RES)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR SINGLE-FLOAT RATIONAL), not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR RATIONAL SINGLE-FLOAT)
;                               &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do safe inline fixnum arithmetic (cost 4) because:
;       The first argument is a (OR SINGLE-FLOAT RATIONAL), not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR RATIONAL SINGLE-FLOAT)
;                               &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF 
; --> AND IF PLUSP 
; ==>
;   (> NUMBER 0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a (OR SINGLE-FLOAT RATIONAL), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (OR SINGLE-FLOAT RATIONAL), not a FIXNUM.
;       etc.

; --> CEILING BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 
; ==>
;   (+ SB-KERNEL::TRU 1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (FLOAT (EXPT CL-PPCRE:*REGEX-CHAR-CODE-LIMIT* (/ 1 4)))
; --> IF 
; ==>
;   (SB-KERNEL:%SINGLE-FLOAT SB-C::N)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a RATIONAL, not a (UNSIGNED-BYTE 32).
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a RATIONAL, not a (SIGNED-BYTE 32).

; compiling (DEFUN MAYBE-SPLIT-REPETITION ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/convert.lisp
; in: DEFUN MAYBE-SPLIT-REPETITION
;     (- CL-PPCRE::MAXIMUM CL-PPCRE::MINIMUM)
; 
; note: doing signed word to integer coercion (cost 20)

; compiling (DEFUN MAYBE-ACCUMULATE ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/convert.lisp
; in: DEFUN MAYBE-ACCUMULATE
;     (SETF (SUBSEQ (SLOT-VALUE CL-PPCRE::STARTS-WITH 'CL-PPCRE::STR)
;                 (- (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH)
;                    (CL-PPCRE::LEN CL-PPCRE::STR)))
;           (CL-PPCRE::STR CL-PPCRE::STR)
;         (CL-PPCRE::SKIP CL-PPCRE::STR)
;           T)
; --> PROGN SETF LET* MULTIPLE-VALUE-BIND LET PROGN 
; ==>
;   (REPLACE #:G77 #:G79 :START1 #:G78 :END1 NIL)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
;   The second argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
;   The result is a (VALUES SEQUENCE
;                           &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The result is a (VALUES SEQUENCE
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY CHARACTER (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
;   The result is a (VALUES SEQUENCE
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY SINGLE-FLOAT (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-BIT-VECTOR.
;   The second argument is a SEQUENCE, not a SIMPLE-BIT-VECTOR.
;   The result is a (VALUES SEQUENCE
;                           &OPTIONAL), not a (VALUES SIMPLE-BIT-VECTOR &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
;   The result is a (VALUES SEQUENCE
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 2)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
;   The result is a (VALUES SEQUENCE
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 4)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*)).
;   The result is a (VALUES SEQUENCE
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 7)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).
;   The result is a (VALUES SEQUENCE
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 8)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 15)
;                                                          (*)).
;   The result is a (VALUES SEQUENCE
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 15)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 16)
;                                                          (*)).
;   The result is a (VALUES SEQUENCE
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 16)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 29) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 29)
;                                                          (*)).
;   The result is a (VALUES SEQUENCE
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 29)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 31)
;                                                          (*)).
;   The result is a (VALUES SEQUENCE
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 31)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 32)
;                                                          (*)).
;   The result is a (VALUES SEQUENCE
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 32)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 8) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 8) (*)).
;   The result is a (VALUES SEQUENCE
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 8) (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 16) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 16) (*)).
;   The result is a (VALUES SEQUENCE
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 16)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY FIXNUM (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY FIXNUM (*)).
;   The result is a (VALUES SEQUENCE
;                           &OPTIONAL), not a (VALUES (SIMPLE-ARRAY FIXNUM (*))
;                                                     &REST
;                                                     T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 32) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 32) (*)).
;   The result is a (VALUES SEQUENCE
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 32)
;                                                            (*))
;                                              &REST
;                                              T).

;     (SETF (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH)
;           (+ (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH)
;              (CL-PPCRE::LEN CL-PPCRE::STR)))
; --> LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL 
; ==>
;   (#<SB-C::GLOBAL-VAR
;      :%SOURCE-NAME (SETF CL-PPCRE::LEN)
;      :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION # *)>
;      :WHERE-FROM :DECLARED
;      :KIND :GLOBAL-FUNCTION {10CFE2C1}>
;    #:G75 #:G76)
; 
; note: doing signed word to integer coercion (cost 20)

; compiling (DEFUN CONVERT-AUX ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/convert.lisp
; in: DEFUN CONVERT-AUX
;     (EVERY (LAMBDA (CL-PPCRE::ITEM) (EQ CL-PPCRE::ITEM :NON-WORD-CHAR-CLASS))
;          CL-PPCRE::ITEM-LIST)
; --> LET BLOCK MAP TRULY-THE 
; ==>
;   (SB-KERNEL:%MAP SB-C::RESULT-TYPE-ARG SB-C::FUN #:G234)
; 
; note: unable to open code because: can't determine sequence argument type

;     (CHAR-EQUAL (FIRST CL-PPCRE::HASH-KEYS) (SECOND CL-PPCRE::HASH-KEYS))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

;     (MEMBER CL-PPCRE::PARSE-TREE
;           '(:NON-DIGIT-CLASS :NON-WORD-CHAR-CLASS :NON-WHITESPACE-CHAR-CLASS)
;           :TEST
;           #'EQ)
; --> BLOCK LET AND IF AND 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::KEY)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
;   The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.

; --> BLOCK LET IF 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::TEST)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
;   The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.

; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-IMPL::TEST-NOT)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
;   The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.

;     (LENGTH (CL-PPCRE::CHOICES CL-PPCRE::ALTERNATIONS))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (ZEROP LENGTH)
; --> = IF 
; ==>
;   (= LENGTH 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

;     (EVERY (LAMBDA (CL-PPCRE::ITEM) (EQ CL-PPCRE::ITEM :WORD-CHAR-CLASS))
;          CL-PPCRE::ITEM-LIST)
; --> LET BLOCK MAP TRULY-THE 
; ==>
;   (SB-KERNEL:%MAP SB-C::RESULT-TYPE-ARG SB-C::FUN #:G244)
; 
; note: unable to open code because: can't determine sequence argument type

;     (1- (THE FIXNUM CL-PPCRE::TEST-CANDIDATE))
; ==>
;   (- (THE FIXNUM CL-PPCRE::TEST-CANDIDATE) 1)
; 
; note: doing signed word to integer coercion (cost 20)

;     (1- CL-PPCRE::MAXIMUM)
; ==>
;   (- CL-PPCRE::MAXIMUM 1)
; 
; note: doing signed word to integer coercion (cost 20)

; compiling (DEFUN CONVERT ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/convert.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/optimize.lisp" (written 13 APR 2005 11:35:57 AM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFGENERIC FLATTEN ...)
; compiling (DEFMETHOD FLATTEN ...)
; compiling (DEFMETHOD FLATTEN ...)
; compiling (DEFMETHOD FLATTEN ...)
; compiling (DEFMETHOD FLATTEN ...)
; compiling (DEFGENERIC GATHER-STRINGS ...)
; compiling (DEFMETHOD GATHER-STRINGS ...)
; compiling (DEFMETHOD GATHER-STRINGS ...)
; compiling (DEFMETHOD GATHER-STRINGS ...)
; compiling (DEFMETHOD GATHER-STRINGS ...)
; compiling (DEFGENERIC START-ANCHORED-P ...)
; compiling (DEFMETHOD START-ANCHORED-P ...)
; compiling (DEFMETHOD START-ANCHORED-P ...)
; compiling (DEFMETHOD START-ANCHORED-P ...)
; compiling (DEFMETHOD START-ANCHORED-P ...)
; compiling (DEFMETHOD START-ANCHORED-P ...)
; compiling (DEFMETHOD START-ANCHORED-P ...)
; compiling (DEFMETHOD START-ANCHORED-P ...)
; compiling (DEFMETHOD START-ANCHORED-P ...)
; compiling (DEFGENERIC END-STRING-AUX ...)
; compiling (DEFMETHOD END-STRING-AUX ...)
; compiling (DEFMETHOD END-STRING-AUX ...)
; compiling (DEFMETHOD END-STRING-AUX ...)
; compiling (DEFMETHOD END-STRING-AUX ...)
; compiling (DEFMETHOD END-STRING-AUX ...)
; compiling (DEFGENERIC END-STRING ...)
; compiling (DEFMETHOD END-STRING ...)
; compiling (DEFGENERIC COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)
; compiling (DEFMETHOD COMPUTE-MIN-REST ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/optimize.fasl written
; compilation finished in 0:00:04
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/closures.lisp" (written 16 MAY 2005 12:29:23 PM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DECLAIM (INLINE *STRING*= ...))
; compiling (DEFUN *STRING*= ...)
; compiling (DEFUN *STRING*-EQUAL ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/closures.lisp
; in: DEFUN *STRING*-EQUAL
;     (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
;               (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

; compiling (DEFGENERIC CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMACRO INSERT-CHAR-CLASS-TESTER ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/closures.lisp
; in: DEFMETHOD CREATE-MATCHER-AUX (CHAR-CLASS T)
;     (FUNCALL CL-PPCRE::NEXT-FN (1+ CL-PPCRE::START-POS))
; ==>
;   CL-PPCRE::NEXT-FN
; 
; note: deleting unreachable code

;     (CL-PPCRE::INSERT-CHAR-CLASS-TESTER
;    (CL-PPCRE::CHAR-CLASS (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
;    (IF (CL-PPCRE::INVERTEDP CL-PPCRE::CHAR-CLASS)
;        (LAMBDA (CL-PPCRE::START-POS)
;          (DECLARE (TYPE FIXNUM CL-PPCRE::START-POS))
;          (AND (< CL-PPCRE::START-POS CL-PPCRE::*END-POS*)
;               (NOT #)
;               (FUNCALL CL-PPCRE::NEXT-FN #)))
;        (LAMBDA (CL-PPCRE::START-POS)
;          (DECLARE (TYPE FIXNUM CL-PPCRE::START-POS))
;          (AND (< CL-PPCRE::START-POS CL-PPCRE::*END-POS*)
;               (CL-PPCRE::CHAR-CLASS-TEST)
;               (FUNCALL CL-PPCRE::NEXT-FN #)))))
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF LAMBDA FUNCTION AND IF AND IF CL-PPCRE::WORD-CHAR-P 
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF LAMBDA FUNCTION AND IF AND IF CL-PPCRE::WORD-CHAR-P 
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF LAMBDA FUNCTION AND IF AND IF NOT IF 
; --> CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF LAMBDA FUNCTION AND IF AND IF NOT IF 
; --> CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = 
; --> IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF LAMBDA FUNCTION AND IF AND IF NOT IF 
; --> CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF LAMBDA FUNCTION AND IF AND IF CL-PPCRE::WORD-CHAR-P 
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/closures.lisp
; in: DEFUN *STRING*-EQUAL
;     (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
;               (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

; compiling (DECLAIM (INLINE WORD-BOUNDARY-P))
; compiling (DEFUN WORD-BOUNDARY-P ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/closures.lisp
; in: DEFUN WORD-BOUNDARY-P
;     (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::1-START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::1-START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

;     (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::1-START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

;     (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/closures.lisp
; in: DEFUN WORD-BOUNDARY-P
;     (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::1-START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::1-START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::1-START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

;     (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::1-START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

;     (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

;     (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::1-START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

;     (CL-PPCRE::WORD-CHAR-P (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS))
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/closures.lisp
; in: DEFUN *STRING*-EQUAL
;     (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
;               (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)
; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/closures.fasl written
; compilation finished in 0:00:03
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.lisp" (written 13 APR 2005 11:35:58 AM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFMACRO INCF-AFTER ...)
; compiling (DEFMACRO GREEDY-CONSTANT-LENGTH-CLOSURE ...)
; compiling (DEFUN CREATE-GREEDY-EVERYTHING-MATCHER ...)
; compiling (DEFGENERIC CREATE-GREEDY-CONSTANT-LENGTH-MATCHER ...)
; compiling (DEFMETHOD CREATE-GREEDY-CONSTANT-LENGTH-MATCHER ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.lisp
; in: DEFMACRO GREEDY-CONSTANT-LENGTH-CLOSURE
;     (INCF CL-PPCRE::CURR-POS CL-PPCRE::LEN)
; --> LET* 
; ==>
;   CL-PPCRE::LEN
; 
; note: deleting unreachable code

; --> LET* + 
; ==>
;   CL-PPCRE::CURR-POS
; 
; note: deleting unreachable code

;     (GO CL-PPCRE::FORWARD-LOOP)
; 
; note: deleting unreachable code

;     (INCF CL-PPCRE::CURR-POS CL-PPCRE::LEN)
; --> LET* 
; ==>
;   CL-PPCRE::LEN
; 
; note: deleting unreachable code

; --> LET* + 
; ==>
;   CL-PPCRE::CURR-POS
; 
; note: deleting unreachable code

;     (GO CL-PPCRE::FORWARD-LOOP)
; 
; note: deleting unreachable code

; in: DEFMETHOD CREATE-GREEDY-CONSTANT-LENGTH-MATCHER (REPETITION T)
;     (CL-PPCRE::INSERT-CHAR-CLASS-TESTER
;    (CL-PPCRE::REGEX (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
;    (IF (CL-PPCRE::INVERTEDP CL-PPCRE::REGEX)
;        (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
;         (NOT (CL-PPCRE::CHAR-CLASS-TEST)))
;        (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE (CL-PPCRE::CHAR-CLASS-TEST))))
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF CL-PPCRE::WORD-CHAR-P BLOCK OR 
; --> LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF CL-PPCRE::WORD-CHAR-P BLOCK OR 
; --> LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF CL-PPCRE::WORD-CHAR-P BLOCK OR 
; --> LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF CL-PPCRE::WORD-CHAR-P BLOCK OR 
; --> LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF NOT IF CL-PPCRE::WORD-CHAR-P 
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF NOT IF CL-PPCRE::WORD-CHAR-P 
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF NOT IF CL-PPCRE::WORD-CHAR-P 
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF NOT IF CL-PPCRE::WORD-CHAR-P 
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STR
;                             CL-PPCRE::CURR-POS
;                             (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN)
;                             0
;                             CL-PPCRE::LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF 
; ==>
;   (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
;               (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

;     (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

;     (CL-PPCRE::INSERT-CHAR-CLASS-TESTER
;    (CL-PPCRE::REGEX (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
;    (IF (CL-PPCRE::INVERTEDP CL-PPCRE::REGEX)
;        (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
;         (NOT (CL-PPCRE::CHAR-CLASS-TEST)))
;        (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE (CL-PPCRE::CHAR-CLASS-TEST))))
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF NOT IF CL-PPCRE::WORD-CHAR-P 
; --> BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET BLOCK TAGBODY WHEN COND IF CL-PPCRE::WORD-CHAR-P BLOCK OR 
; --> LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; compiling (DEFGENERIC CREATE-GREEDY-NO-ZERO-MATCHER ...)
; compiling (DEFMETHOD CREATE-GREEDY-NO-ZERO-MATCHER ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.lisp
; in: DEFMETHOD CREATE-GREEDY-NO-ZERO-MATCHER (REPETITION T)
;     (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) 0)
; --> SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* + AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* - AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; compiling (DEFGENERIC CREATE-GREEDY-MATCHER ...)
; compiling (DEFMETHOD CREATE-GREEDY-MATCHER ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.lisp
; in: DEFMETHOD CREATE-GREEDY-MATCHER (REPETITION T)
;     (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
;           0
;         (SVREF CL-PPCRE::*LAST-POS-STORES* CL-PPCRE::ZERO-LENGTH-NUM)
;           NIL)
; --> PROGN SETF SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* + AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* - AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; compiling (DEFMACRO NON-GREEDY-CONSTANT-LENGTH-CLOSURE ...)
; compiling (DEFGENERIC CREATE-NON-GREEDY-CONSTANT-LENGTH-MATCHER ...)
; compiling (DEFMETHOD CREATE-NON-GREEDY-CONSTANT-LENGTH-MATCHER ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.lisp
; in: DEFMETHOD CREATE-NON-GREEDY-CONSTANT-LENGTH-MATCHER (REPETITION T)
;     (CL-PPCRE::INSERT-CHAR-CLASS-TESTER
;    (CL-PPCRE::REGEX (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
;    (IF (CL-PPCRE::INVERTEDP CL-PPCRE::REGEX)
;        (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
;         (NOT (CL-PPCRE::CHAR-CLASS-TEST)))
;        (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
;         (CL-PPCRE::CHAR-CLASS-TEST))))
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF 
; --> NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET 
; --> < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF 
; --> NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET 
; --> IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF 
; --> NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET 
; --> < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF 
; --> NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET 
; --> IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF 
; --> NOT IF NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET 
; --> OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF 
; --> NOT IF NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET 
; --> OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF 
; --> NOT IF NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET 
; --> OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF 
; --> NOT IF NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET 
; --> OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STR
;                             CL-PPCRE::CURR-POS
;                             (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN)
;                             0
;                             CL-PPCRE::LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF 
; ==>
;   (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
;               (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

;     (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

;     (CL-PPCRE::INSERT-CHAR-CLASS-TESTER
;    (CL-PPCRE::REGEX (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
;    (IF (CL-PPCRE::INVERTEDP CL-PPCRE::REGEX)
;        (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
;         (NOT (CL-PPCRE::CHAR-CLASS-TEST)))
;        (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
;         (CL-PPCRE::CHAR-CLASS-TEST))))
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF 
; --> NOT IF NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET 
; --> OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA 
; --> FUNCTION LET LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF 
; --> NOT IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET ALPHANUMERICP BLOCK LET OR LET 
; --> < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; compiling (DEFGENERIC CREATE-NON-GREEDY-NO-ZERO-MATCHER ...)
; compiling (DEFMETHOD CREATE-NON-GREEDY-NO-ZERO-MATCHER ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.lisp
; in: DEFMETHOD CREATE-NON-GREEDY-NO-ZERO-MATCHER (REPETITION T)
;     (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) 0)
; --> SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* + AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* - AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; compiling (DEFGENERIC CREATE-NON-GREEDY-MATCHER ...)
; compiling (DEFMETHOD CREATE-NON-GREEDY-MATCHER ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.lisp
; in: DEFMETHOD CREATE-NON-GREEDY-MATCHER (REPETITION T)
;     (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
;           0
;         (SVREF CL-PPCRE::*LAST-POS-STORES* CL-PPCRE::ZERO-LENGTH-NUM)
;           NIL)
; --> PROGN SETF SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* + AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* - AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; compiling (DEFMACRO CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE ...)
; compiling (DEFGENERIC CREATE-CONSTANT-REPETITION-CONSTANT-LENGTH-MATCHER ...)
; compiling (DEFMETHOD CREATE-CONSTANT-REPETITION-CONSTANT-LENGTH-MATCHER ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.lisp
; in:
;      DEFMETHOD CREATE-CONSTANT-REPETITION-CONSTANT-LENGTH-MATCHER (REPETITION T)
;     (1+ CL-PPCRE::CURR-POS)
; --> + 
; ==>
;   CL-PPCRE::CURR-POS
; 
; note: deleting unreachable code

;     (CL-PPCRE::INSERT-CHAR-CLASS-TESTER
;    (CL-PPCRE::REGEX (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
;    (IF (CL-PPCRE::INVERTEDP CL-PPCRE::REGEX)
;        (CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
;         (AND (NOT #) (1+ CL-PPCRE::CURR-POS)))
;        (CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
;         (AND (CL-PPCRE::CHAR-CLASS-TEST) (1+ CL-PPCRE::CURR-POS)))))
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE 
; --> LAMBDA FUNCTION LET AND IF AND IF LOOP BLOCK LET SB-LOOP::LOOP-BODY 
; --> TAGBODY UNLESS COND IF NOT IF AND IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET 
; --> ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE 
; --> LAMBDA FUNCTION LET AND IF AND IF LOOP BLOCK LET SB-LOOP::LOOP-BODY 
; --> TAGBODY UNLESS COND IF NOT IF AND IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET 
; --> ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE 
; --> LAMBDA FUNCTION LET AND IF AND IF LOOP BLOCK LET SB-LOOP::LOOP-BODY 
; --> TAGBODY UNLESS COND IF NOT IF AND IF NOT IF CL-PPCRE::WORD-CHAR-P BLOCK 
; --> OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE 
; --> LAMBDA FUNCTION LET AND IF AND IF LOOP BLOCK LET SB-LOOP::LOOP-BODY 
; --> TAGBODY UNLESS COND IF NOT IF AND IF NOT IF CL-PPCRE::WORD-CHAR-P BLOCK 
; --> OR LET ALPHANUMERICP BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STR
;                             CL-PPCRE::CURR-POS
;                             CL-PPCRE::NEXT-POS
;                             0
;                             CL-PPCRE::LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF 
; ==>
;   (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
;               (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

;     (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

;     (CL-PPCRE::INSERT-CHAR-CLASS-TESTER
;    (CL-PPCRE::REGEX (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
;    (IF (CL-PPCRE::INVERTEDP CL-PPCRE::REGEX)
;        (CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
;         (AND (NOT #) (1+ CL-PPCRE::CURR-POS)))
;        (CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
;         (AND (CL-PPCRE::CHAR-CLASS-TEST) (1+ CL-PPCRE::CURR-POS)))))
; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE 
; --> LAMBDA FUNCTION LET AND IF AND IF LOOP BLOCK LET SB-LOOP::LOOP-BODY 
; --> TAGBODY UNLESS COND IF NOT IF AND IF NOT IF CL-PPCRE::WORD-CHAR-P BLOCK 
; --> OR LET ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; --> LET* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION COND IF COND IF 
; --> COND IF PROGN IF CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE 
; --> LAMBDA FUNCTION LET AND IF AND IF LOOP BLOCK LET SB-LOOP::LOOP-BODY 
; --> TAGBODY UNLESS COND IF NOT IF AND IF CL-PPCRE::WORD-CHAR-P BLOCK OR LET 
; --> ALPHANUMERICP BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; compiling (DEFGENERIC CREATE-CONSTANT-REPETITION-MATCHER ...)
; compiling (DEFMETHOD CREATE-CONSTANT-REPETITION-MATCHER ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.lisp
; in: DEFMETHOD CREATE-CONSTANT-REPETITION-MATCHER (REPETITION T)
;     (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) 0)
; --> SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* + AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* - AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
;           0
;         (AREF CL-PPCRE::*LAST-POS-STORES* CL-PPCRE::ZERO-LENGTH-NUM)
;           NIL)
; --> PROGN SETF SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (ZEROP (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION))
; ==>
;   (= (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

;     (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; --> LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* + AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> LET* - AREF LET* SB-KERNEL:HAIRY-DATA-VECTOR-REF MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> LET* SB-KERNEL:%ASET LET* SB-KERNEL:HAIRY-DATA-VECTOR-SET 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%DATA-VECTOR-AND-INDEX ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; compiling (DEFMETHOD CREATE-MATCHER-AUX ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/repetition-closures.fasl written
; compilation finished in 0:00:09
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/scanner.lisp" (written 19 JUL 2005 07:18:15 PM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFMACRO BMH-MATCHER-AUX ...)
; compiling (DEFUN CREATE-BMH-MATCHER ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/scanner.lisp
; in: DEFUN CREATE-BMH-MATCHER
;     (CL-PPCRE::BMH-MATCHER-AUX :CASE-INSENSITIVE-P T)
; --> LAMBDA FUNCTION IF LOOP BLOCK LET SB-LOOP::LOOP-BODY TAGBODY LOOP BLOCK 
; --> LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF AND IF AND 
; ==>
;   (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::I)
;               (SCHAR CL-PPCRE::PATTERN CL-PPCRE::J))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

;     (LENGTH CL-PPCRE::PATTERN)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (CHAR-UPCASE (SCHAR CL-PPCRE::PATTERN CL-PPCRE::K))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.

;     (CHAR-DOWNCASE (SCHAR CL-PPCRE::PATTERN CL-PPCRE::K))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.

;     (SEARCH CL-PPCRE::PATTERN
;           CL-PPCRE::*STRING*
;           :START2
;           CL-PPCRE::START-POS
;           :END2
;           CL-PPCRE::*END-POS*
;           :TEST
;           CL-PPCRE::TEST)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-STRING.

; compiling (DEFMACRO CHAR-SEARCHER-AUX ...)
; compiling (DEFUN CREATE-CHAR-SEARCHER ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/scanner.lisp
; in: DEFUN CREATE-CHAR-SEARCHER
;     (CL-PPCRE::CHAR-SEARCHER-AUX :CASE-INSENSITIVE-P T)
; --> LAMBDA FUNCTION AND IF AND LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY 
; --> WHEN COND IF SETQ THE AND IF 
; ==>
;   (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::I) CL-PPCRE::CHR)
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

; compiling (DECLAIM (INLINE NEWLINE-SKIPPER))
; compiling (DEFUN NEWLINE-SKIPPER ...)
; compiling (DEFMACRO INSERT-ADVANCE-FN ...)
; compiling (DEFUN CREATE-SCANNER-AUX ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/scanner.lisp
; in: DEFMACRO INSERT-ADVANCE-FN
;     (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STARTS-WITH-STR
;                             CL-PPCRE::*START-POS*
;                             (+ CL-PPCRE::*START-POS* CL-PPCRE::STARTS-WITH-LEN)
;                             0
;                             CL-PPCRE::STARTS-WITH-LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF 
; ==>
;   (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
;               (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

;     (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;      CL-PPCRE::*END-POS*)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET* 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* #:G274)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STARTS-WITH-STR
;                             CL-PPCRE::*START-POS*
;                             (+ CL-PPCRE::*START-POS* CL-PPCRE::STARTS-WITH-LEN)
;                             0
;                             CL-PPCRE::STARTS-WITH-LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF 
; ==>
;   (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
;               (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

;     (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;      CL-PPCRE::*END-POS*)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET* 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* #:G264)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STARTS-WITH-STR
;                             CL-PPCRE::*START-POS*
;                             (+ CL-PPCRE::*START-POS* CL-PPCRE::STARTS-WITH-LEN)
;                             0
;                             CL-PPCRE::STARTS-WITH-LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF 
; ==>
;   (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
;               (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

;     (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;      CL-PPCRE::*END-POS*)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET* 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* #:G254)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STARTS-WITH-STR
;                             CL-PPCRE::*START-POS*
;                             (+ CL-PPCRE::*START-POS* CL-PPCRE::STARTS-WITH-LEN)
;                             0
;                             CL-PPCRE::STARTS-WITH-LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF 
; ==>
;   (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
;               (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

;     (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;      CL-PPCRE::*END-POS*)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET* 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* #:G244)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STARTS-WITH-STR
;                             CL-PPCRE::*START-POS*
;                             (+ CL-PPCRE::*START-POS* CL-PPCRE::STARTS-WITH-LEN)
;                             0
;                             CL-PPCRE::STARTS-WITH-LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF 
; ==>
;   (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
;               (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

;     (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;      CL-PPCRE::*END-POS*)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET* 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* #:G234)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STARTS-WITH-STR
;                             CL-PPCRE::*START-POS*
;                             (+ CL-PPCRE::*START-POS* CL-PPCRE::STARTS-WITH-LEN)
;                             0
;                             CL-PPCRE::STARTS-WITH-LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF 
; ==>
;   (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
;               (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

;     (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;      CL-PPCRE::*END-POS*)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET* 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* #:G224)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STARTS-WITH-STR
;                             CL-PPCRE::*START-POS*
;                             (+ CL-PPCRE::*START-POS* CL-PPCRE::STARTS-WITH-LEN)
;                             0
;                             CL-PPCRE::STARTS-WITH-LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF 
; ==>
;   (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
;               (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

;     (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;      CL-PPCRE::*END-POS*)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET* 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* #:G214)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STARTS-WITH-STR
;                             CL-PPCRE::*START-POS*
;                             (+ CL-PPCRE::*START-POS* CL-PPCRE::STARTS-WITH-LEN)
;                             0
;                             CL-PPCRE::STARTS-WITH-LEN)
; --> BLOCK LOOP BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT IF 
; ==>
;   (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::STRING1-IDX)
;               (SCHAR CL-PPCRE::STRING2 CL-PPCRE::STRING2-IDX))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

;     (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;      CL-PPCRE::*END-POS*)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET* 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* #:G200)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; --> IF 
; ==>
;   (> CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a REAL, not a FIXNUM.

;     (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;      CL-PPCRE::*END-POS*)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.

;     (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET* 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* #:G214)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; --> IF 
; ==>
;   (> CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a REAL, not a FIXNUM.

;     (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;      CL-PPCRE::*END-POS*)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.

;     (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET* 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* #:G200)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; --> IF 
; ==>
;   (> CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a REAL, not a FIXNUM.

;     (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;      CL-PPCRE::*END-POS*)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.

;     (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET* 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* #:G224)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; --> IF 
; ==>
;   (> CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a REAL, not a FIXNUM.

;     (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;      CL-PPCRE::*END-POS*)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.

;     (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET* 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* #:G234)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; --> IF 
; ==>
;   (> CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a REAL, not a FIXNUM.

;     (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;      CL-PPCRE::*END-POS*)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.

;     (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET* 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* #:G244)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; --> IF 
; ==>
;   (> CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a REAL, not a FIXNUM.

;     (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;      CL-PPCRE::*END-POS*)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.

;     (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET* 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* #:G254)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; --> IF 
; ==>
;   (> CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a REAL, not a FIXNUM.

;     (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;      CL-PPCRE::*END-POS*)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.

;     (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET* 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* #:G264)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (<= CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; --> IF 
; ==>
;   (> CL-PPCRE::*START-POS* CL-PPCRE::*END-STRING-POS*)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a REAL, not a FIXNUM.

;     (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (< (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
;      CL-PPCRE::*END-POS*)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.

;     (INCF CL-PPCRE::*END-STRING-POS*)
; --> LET* 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* #:G274)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; in: DEFUN CREATE-SCANNER-AUX
;     (CL-PPCRE::INSERT-ADVANCE-FN
;    (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS) CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* 
; ==>
;   (SB-C::%SPECIAL-BIND
;    '#<SB-C::GLOBAL-VAR
;       :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;       :KIND :SPECIAL {1015C469}>
;    #<SB-C::LAMBDA-VAR
;      :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;      :SPECVAR #<SB-C::GLOBAL-VAR
;                 :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;                 :KIND :SPECIAL {1015C469}> {108D6511}>)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first argument of BIND

; in: DEFMACRO INSERT-ADVANCE-FN
;     (FUNCALL CL-PPCRE::END-STRING-TEST (1- CL-PPCRE::END-TEST-POS))
; ==>
;   (SB-C::%FUNCALL FUNCTION #:G607)
; 
; note: doing signed word to integer coercion (cost 20)

; in: DEFUN CREATE-SCANNER-AUX
;     (CL-PPCRE::INSERT-ADVANCE-FN
;    (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;                          (DECLARE (TYPE FUNCTION CL-PPCRE::END-STRING-TEST))
;                          (IF
;                           (<= (THE FIXNUM CL-PPCRE::POS)
;                               (THE FIXNUM CL-PPCRE::*END-STRING-POS*))
;                           (RETURN-FROM CL-PPCRE::ADVANCE-FN CL-PPCRE::POS))
;                          (UNLESS
;                              (SETQ CL-PPCRE::*END-STRING-POS*
;                                      (FUNCALL CL-PPCRE::END-STRING-TEST
;                                               CL-PPCRE::POS))
;                            (RETURN-FROM CL-PPCRE:SCAN NIL))
;                          CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* 
; ==>
;   (SB-C::%SPECIAL-BIND
;    '#<SB-C::GLOBAL-VAR
;       :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;       :KIND :SPECIAL {1015C469}>
;    #<SB-C::LAMBDA-VAR
;      :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;      :SPECVAR #<SB-C::GLOBAL-VAR
;                 :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;                 :KIND :SPECIAL {1015C469}> {108D6589}>)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first argument of BIND

; in: DEFMACRO INSERT-ADVANCE-FN
;     (FUNCALL CL-PPCRE::END-STRING-TEST (1- CL-PPCRE::END-TEST-POS))
; ==>
;   (SB-C::%FUNCALL FUNCTION #:G854)
; 
; note: doing signed word to integer coercion (cost 20)

; in: DEFUN CREATE-SCANNER-AUX
;     (CL-PPCRE::INSERT-ADVANCE-FN
;    (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;                          (UNLESS
;                              (SETQ CL-PPCRE::POS
;                                      (CL-PPCRE::NEWLINE-SKIPPER CL-PPCRE::POS))
;                            (RETURN-FROM CL-PPCRE:SCAN NIL))
;                          CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* 
; ==>
;   (SB-C::%SPECIAL-BIND
;    '#<SB-C::GLOBAL-VAR
;       :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;       :KIND :SPECIAL {1015C469}>
;    #<SB-C::LAMBDA-VAR
;      :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;      :SPECVAR #<SB-C::GLOBAL-VAR
;                 :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;                 :KIND :SPECIAL {1015C469}> {108D6601}>)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first argument of BIND

; in: DEFMACRO INSERT-ADVANCE-FN
;     (FUNCALL CL-PPCRE::END-STRING-TEST (1- CL-PPCRE::END-TEST-POS))
; ==>
;   (SB-C::%FUNCALL FUNCTION #:G1101)
; 
; note: doing signed word to integer coercion (cost 20)

; in: DEFUN CREATE-SCANNER-AUX
;     (CL-PPCRE::INSERT-ADVANCE-FN
;    (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;                          (DECLARE (TYPE FUNCTION CL-PPCRE::START-STRING-TEST))
;                          (UNLESS
;                              (SETQ CL-PPCRE::POS
;                                      (FUNCALL CL-PPCRE::START-STRING-TEST
;                                               CL-PPCRE::POS))
;                            (RETURN-FROM CL-PPCRE:SCAN NIL))
;                          CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* 
; ==>
;   (SB-C::%SPECIAL-BIND
;    '#<SB-C::GLOBAL-VAR
;       :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;       :KIND :SPECIAL {1015C469}>
;    #<SB-C::LAMBDA-VAR
;      :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;      :SPECVAR #<SB-C::GLOBAL-VAR
;                 :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;                 :KIND :SPECIAL {1015C469}> {108D6679}>)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first argument of BIND

; in: DEFMACRO INSERT-ADVANCE-FN
;     (FUNCALL CL-PPCRE::END-STRING-TEST (1- CL-PPCRE::END-TEST-POS))
; ==>
;   (SB-C::%FUNCALL FUNCTION #:G1348)
; 
; note: doing signed word to integer coercion (cost 20)

; in: DEFUN CREATE-SCANNER-AUX
;     (CL-PPCRE::INSERT-ADVANCE-FN
;    (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;                          (DECLARE (TYPE FUNCTION CL-PPCRE::END-STRING-TEST))
;                          (UNLESS
;                              (SETQ CL-PPCRE::POS
;                                      (CL-PPCRE::NEWLINE-SKIPPER CL-PPCRE::POS))
;                            (RETURN-FROM CL-PPCRE:SCAN NIL))
;                          (IF
;                           (<= (THE FIXNUM CL-PPCRE::POS)
;                               (THE FIXNUM CL-PPCRE::*END-STRING-POS*))
;                           (RETURN-FROM CL-PPCRE::ADVANCE-FN CL-PPCRE::POS))
;                          (UNLESS
;                              (SETQ CL-PPCRE::*END-STRING-POS*
;                                      (FUNCALL CL-PPCRE::END-STRING-TEST
;                                               CL-PPCRE::POS))
;                            (RETURN-FROM CL-PPCRE:SCAN NIL))
;                          CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* 
; ==>
;   (SB-C::%SPECIAL-BIND
;    '#<SB-C::GLOBAL-VAR
;       :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;       :KIND :SPECIAL {1015C469}>
;    #<SB-C::LAMBDA-VAR
;      :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;      :SPECVAR #<SB-C::GLOBAL-VAR
;                 :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;                 :KIND :SPECIAL {1015C469}> {108D66F1}>)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first argument of BIND

; in: DEFMACRO INSERT-ADVANCE-FN
;     (FUNCALL CL-PPCRE::END-STRING-TEST (1- CL-PPCRE::END-TEST-POS))
; ==>
;   (SB-C::%FUNCALL FUNCTION #:G1596)
; 
; note: doing signed word to integer coercion (cost 20)

; in: DEFUN CREATE-SCANNER-AUX
;     (CL-PPCRE::INSERT-ADVANCE-FN
;    (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;                          (DECLARE
;                           (TYPE FUNCTION
;                                 CL-PPCRE::START-STRING-TEST
;                                 CL-PPCRE::END-STRING-TEST))
;                          (UNLESS
;                              (SETQ CL-PPCRE::POS
;                                      (FUNCALL CL-PPCRE::START-STRING-TEST
;                                               CL-PPCRE::POS))
;                            (RETURN-FROM CL-PPCRE:SCAN NIL))
;                          (IF
;                           (<= (THE FIXNUM CL-PPCRE::POS)
;                               (THE FIXNUM CL-PPCRE::*END-STRING-POS*))
;                           (RETURN-FROM CL-PPCRE::ADVANCE-FN CL-PPCRE::POS))
;                          (UNLESS
;                              (SETQ CL-PPCRE::*END-STRING-POS*
;                                      (FUNCALL CL-PPCRE::END-STRING-TEST
;                                               CL-PPCRE::POS))
;                            (RETURN-FROM CL-PPCRE:SCAN NIL))
;                          CL-PPCRE::POS))
; --> LAMBDA FUNCTION BLOCK LET* 
; ==>
;   (SB-C::%SPECIAL-BIND
;    '#<SB-C::GLOBAL-VAR
;       :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;       :KIND :SPECIAL {1015C469}>
;    #<SB-C::LAMBDA-VAR
;      :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;      :SPECVAR #<SB-C::GLOBAL-VAR
;                 :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;                 :KIND :SPECIAL {1015C469}> {108D6769}>)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first argument of BIND

; in: DEFMACRO INSERT-ADVANCE-FN
;     (FUNCALL CL-PPCRE::END-STRING-TEST (1- CL-PPCRE::END-TEST-POS))
; ==>
;   (SB-C::%FUNCALL FUNCTION #:G1845)
; 
; note: doing signed word to integer coercion (cost 20)

; in: DEFUN CREATE-SCANNER-AUX
;     (CL-PPCRE::INSERT-ADVANCE-FN
;    (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;                          (DECLARE (TYPE FIXNUM CL-PPCRE::END-STRING-OFFSET)
;                                   (TYPE FUNCTION CL-PPCRE::END-STRING-TEST))
;                          (LOOP
;                           (UNLESS (SETQ CL-PPCRE::POS #)
;                             (RETURN-FROM CL-PPCRE:SCAN NIL))
;                           (LOCALLY
;                            (DECLARE #)
;                            (WHEN # #)
;                            (LET #
;                              #)))))
; --> LAMBDA FUNCTION BLOCK LET* 
; ==>
;   (SB-C::%SPECIAL-BIND
;    '#<SB-C::GLOBAL-VAR
;       :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;       :KIND :SPECIAL {1015C469}>
;    #<SB-C::LAMBDA-VAR
;      :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;      :SPECVAR #<SB-C::GLOBAL-VAR
;                 :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;                 :KIND :SPECIAL {1015C469}> {108D67E1}>)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first argument of BIND

;     (SETQ CL-PPCRE::TRY-POS (1+ CL-PPCRE::*END-STRING-POS*))
; 
; note: doing signed word to integer coercion (cost 20) to TRY-POS
; 
; note: doing signed word to integer coercion (cost 20) to TRY-POS

; in: DEFMACRO INSERT-ADVANCE-FN
;     (FUNCALL CL-PPCRE::END-STRING-TEST (1- CL-PPCRE::END-TEST-POS))
; ==>
;   (SB-C::%FUNCALL FUNCTION #:G2094)
; 
; note: doing signed word to integer coercion (cost 20)

; in: DEFUN CREATE-SCANNER-AUX
;     (CL-PPCRE::INSERT-ADVANCE-FN
;    (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;                          (DECLARE
;                           (TYPE FIXNUM
;                                 CL-PPCRE::END-STRING-OFFSET
;                                 CL-PPCRE::STARTS-WITH-LEN)
;                           (TYPE FUNCTION
;                                 CL-PPCRE::START-STRING-TEST
;                                 CL-PPCRE::END-STRING-TEST))
;                          (LOOP
;                           (UNLESS (SETQ CL-PPCRE::POS #)
;                             (RETURN-FROM CL-PPCRE:SCAN NIL))
;                           (LOCALLY
;                            (DECLARE #)
;                            (WHEN # #)
;                            (LET #
;                              #)))))
; --> LAMBDA FUNCTION BLOCK LET* 
; ==>
;   (SB-C::%SPECIAL-BIND
;    '#<SB-C::GLOBAL-VAR
;       :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;       :KIND :SPECIAL {1015C469}>
;    #<SB-C::LAMBDA-VAR
;      :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;      :SPECVAR #<SB-C::GLOBAL-VAR
;                 :%SOURCE-NAME CL-PPCRE::*END-STRING-POS*
;                 :KIND :SPECIAL {1015C469}> {108D6859}>)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first argument of BIND

;     (FUNCALL CL-PPCRE::END-STRING-TEST CL-PPCRE::TRY-POS)
; ==>
;   (SB-C::%FUNCALL FUNCTION #:G2348)
; 
; note: doing signed word to integer coercion (cost 20) from TRY-POS

; ==>
;   (SB-C::%FUNCALL FUNCTION #:G2100)
; 
; note: doing signed word to integer coercion (cost 20) from TRY-POS

; in: DEFMACRO INSERT-ADVANCE-FN
;     (FUNCALL CL-PPCRE::END-STRING-TEST (1- CL-PPCRE::END-TEST-POS))
; ==>
;   (SB-C::%FUNCALL FUNCTION #:G2343)
; 
; note: doing signed word to integer coercion (cost 20)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/scanner.fasl written
; compilation finished in 0:00:05
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp" (written 06 DEC 2005 11:50:50 AM):
; compiling (IN-PACKAGE #:CL-PPCRE)
; compiling (DEFGENERIC CREATE-SCANNER ...)
; compiling (DEFMETHOD CREATE-SCANNER ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFMETHOD CREATE-SCANNER (STRING)
;     (COPY-SEQ CL-PPCRE::QUOTED-REGEX-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY CHARACTER (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY SINGLE-FLOAT (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-BIT-VECTOR.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BIT-VECTOR &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 2)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 4)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 7)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 8)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 15)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 16)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 29) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 29)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 31)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 32)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 8) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 8) (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 16) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 16)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY FIXNUM (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES (SIMPLE-ARRAY FIXNUM (*))
;                                                     &REST
;                                                     T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 32) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 32)
;                                                            (*))
;                                              &REST
;                                              T).

; compiling (DEFMETHOD CREATE-SCANNER ...)
; compiling (DEFMETHOD CREATE-SCANNER ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFMETHOD CREATE-SCANNER (T)
;     (PLUSP (CL-PPCRE::LEN CL-PPCRE::END-STRING))
; ==>
;   (> (CL-PPCRE::LEN CL-PPCRE::END-STRING) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (= 1 (CL-PPCRE::LEN CL-PPCRE::END-STRING))
; --> = IF 
; ==>
;   (= SB-C::Y 1)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

;     (PLUSP (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH))
; ==>
;   (> (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (= 1 (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH))
; --> = IF 
; ==>
;   (= SB-C::Y 1)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

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

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

; compiling (DEFGENERIC SCAN ...)
; compiling (DEFMETHOD SCAN ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFMETHOD SCAN (STRING T)
;     (LENGTH CL-PPCRE::TARGET-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (FUNCALL (CL-PPCRE:CREATE-SCANNER CL-PPCRE::REGEX-STRING)
;            (CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING CL-PPCRE::TARGET-STRING)
;            CL-PPCRE::START
;            CL-PPCRE::END)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
;   The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.

; compiling (DEFMETHOD SCAN ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFMETHOD SCAN #'T
;     (LENGTH CL-PPCRE::TARGET-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; compiling (DEFMETHOD SCAN ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFMETHOD SCAN (T T)
;     (LENGTH CL-PPCRE::TARGET-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (FUNCALL (CL-PPCRE:CREATE-SCANNER CL-PPCRE::PARSE-TREE)
;            (CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING CL-PPCRE::TARGET-STRING)
;            CL-PPCRE::START
;            CL-PPCRE::END)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
;   The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.

; compiling (DEFINE-COMPILER-MACRO SCAN ...)
; compiling (DEFUN SCAN-TO-STRINGS ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN SCAN-TO-STRINGS
;     (MAP 'VECTOR
;        (LAMBDA (CL-PPCRE::REG-START CL-PPCRE::REG-END)
;          (IF CL-PPCRE::REG-START
;              (FUNCALL CL-PPCRE::SUBSTR-FN
;                       CL-PPCRE::TARGET-STRING
;                       CL-PPCRE::REG-START
;                       CL-PPCRE::REG-END)
;              NIL))
;        CL-PPCRE::REG-STARTS
;        CL-PPCRE::REG-ENDS)
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAP SB-C::RESULT-TYPE-ARG SB-C::FUN #:G235 #:G236)
; 
; note: unable to open code because: can't determine sequence argument type

;     (LENGTH CL-PPCRE::TARGET-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; compiling (DEFINE-COMPILER-MACRO SCAN-TO-STRINGS ...)
; compiling (DEFMACRO REGISTER-GROUPS-BIND ...)
; compiling (DEFMACRO DO-SCANS ...)
; compiling (DEFMACRO DO-MATCHES ...)
; compiling (DEFMACRO DO-MATCHES-AS-STRINGS ...)
; compiling (DEFMACRO DO-REGISTER-GROUPS ...)
; compiling (DEFUN ALL-MATCHES ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN ALL-MATCHES
;     (CL-PPCRE:DO-MATCHES
;    (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
;                           CL-PPCRE::REGEX
;                           CL-PPCRE::TARGET-STRING
;                           (NREVERSE CL-PPCRE::RESULT-LIST)
;                           :START
;                           CL-PPCRE::START
;                           :END
;                           CL-PPCRE::END)
;    (PUSH CL-PPCRE::MATCH-START CL-PPCRE::RESULT-LIST)
;    (PUSH CL-PPCRE::MATCH-END CL-PPCRE::RESULT-LIST))
; --> CL-PPCRE:DO-SCANS LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 
; ==>
;   (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; --> CL-PPCRE:DO-SCANS LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 1+ 
; ==>
;   (+ CL-PPCRE::MATCH-END 1)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (LENGTH CL-PPCRE::TARGET-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (CL-PPCRE:DO-MATCHES
;    (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
;                           CL-PPCRE::REGEX
;                           CL-PPCRE::TARGET-STRING
;                           (NREVERSE CL-PPCRE::RESULT-LIST)
;                           :START
;                           CL-PPCRE::START
;                           :END
;                           CL-PPCRE::END)
;    (PUSH CL-PPCRE::MATCH-START CL-PPCRE::RESULT-LIST)
;    (PUSH CL-PPCRE::MATCH-END CL-PPCRE::RESULT-LIST))
; --> CL-PPCRE:DO-SCANS LET BLOCK LET* OR LET IF OR 
; ==>
;   (LENGTH #:TARGET-STRING334)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> CL-PPCRE:DO-SCANS LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 
; ==>
;   (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.

; --> CL-PPCRE:DO-SCANS LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 1+ 
; ==>
;   (+ CL-PPCRE::MATCH-END 1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; compiling (DEFINE-COMPILER-MACRO ALL-MATCHES ...)
; compiling (DEFUN ALL-MATCHES-AS-STRINGS ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN ALL-MATCHES-AS-STRINGS
;     (CL-PPCRE:DO-MATCHES-AS-STRINGS
;    (CL-PPCRE::MATCH CL-PPCRE::REGEX
;                     CL-PPCRE::TARGET-STRING
;                     (NREVERSE CL-PPCRE::RESULT-LIST)
;                     :START
;                     CL-PPCRE::START
;                     :END
;                     CL-PPCRE::END
;                     :SHAREDP
;                     CL-PPCRE::SHAREDP)
;    (PUSH CL-PPCRE::MATCH CL-PPCRE::RESULT-LIST))
; --> LET LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* BLOCK 
; --> TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 
; ==>
;   (= #:MATCH-START382 #:MATCH-END383)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; --> LET LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* BLOCK 
; --> TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 1+ 
; ==>
;   (+ #:MATCH-END383 1)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (LENGTH CL-PPCRE::TARGET-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (CL-PPCRE:DO-MATCHES-AS-STRINGS
;    (CL-PPCRE::MATCH CL-PPCRE::REGEX
;                     CL-PPCRE::TARGET-STRING
;                     (NREVERSE CL-PPCRE::RESULT-LIST)
;                     :START
;                     CL-PPCRE::START
;                     :END
;                     CL-PPCRE::END
;                     :SHAREDP
;                     CL-PPCRE::SHAREDP)
;    (PUSH CL-PPCRE::MATCH CL-PPCRE::RESULT-LIST))
; --> LET LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* OR LET IF OR 
; ==>
;   (LENGTH #:TARGET-STRING387)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> LET LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* BLOCK 
; --> TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 
; ==>
;   (= #:MATCH-START382 #:MATCH-END383)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.

; --> LET LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* BLOCK 
; --> TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 1+ 
; ==>
;   (+ #:MATCH-END383 1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; compiling (DEFINE-COMPILER-MACRO ALL-MATCHES-AS-STRINGS ...)
; compiling (DEFUN SPLIT ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN SPLIT
;     (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

;     (= CL-PPCRE::MATCH-START (CAR CL-PPCRE::POS-LIST))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

;     (> CL-PPCRE::THIS-END CL-PPCRE::THIS-START)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (LOOP CL-PPCRE::FOR
;         CL-PPCRE::REG-START
;         CL-PPCRE::ACROSS
;         CL-PPCRE::REG-STARTS
;         CL-PPCRE::FOR
;         CL-PPCRE::REG-END
;         CL-PPCRE::ACROSS
;         CL-PPCRE::REG-ENDS
;         IF
;         CL-PPCRE::REG-START
;         DO
;         ...)
; --> BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY SETQ THE 
; ==>
;   (LENGTH #:LOOP-ACROSS-VECTOR-449)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR NULL VECTOR), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR NULL VECTOR), not a VECTOR.

; ==>
;   (LENGTH #:LOOP-ACROSS-VECTOR-452)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR NULL VECTOR), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR NULL VECTOR), not a VECTOR.

; --> BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY SB-LOOP::LOOP-REALLY-DESETQ SETQ 
; --> THE AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.

;     (CL-PPCRE:DO-SCANS
;    (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
;                           CL-PPCRE::REG-STARTS
;                           CL-PPCRE::REG-ENDS
;                           CL-PPCRE::REGEX
;                           CL-PPCRE::TARGET-STRING
;                           NIL
;                           :START
;                           CL-PPCRE::START
;                           :END
;                           CL-PPCRE::END)
;    (UNLESS
;        (AND (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;             (= CL-PPCRE::MATCH-START (CAR CL-PPCRE::POS-LIST)))
;      (WHEN (AND CL-PPCRE::LIMIT (>= # CL-PPCRE::LIMIT)) (RETURN))
;      (PUSH CL-PPCRE::MATCH-START CL-PPCRE::POS-LIST)
;      (WHEN CL-PPCRE::WITH-REGISTERS-P
;        (LOOP CL-PPCRE::FOR
;              CL-PPCRE::REG-START
;              CL-PPCRE::ACROSS
;              CL-PPCRE::REG-STARTS
;              CL-PPCRE::FOR
;              CL-PPCRE::REG-END
;              CL-PPCRE::ACROSS
;              CL-PPCRE::REG-ENDS
;              IF
;              CL-PPCRE::REG-START
;              DO
;              ...))
;      (PUSH CL-PPCRE::MATCH-END CL-PPCRE::POS-LIST)))
; --> LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION SETQ THE IF 
; ==>
;   (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; --> LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION SETQ THE IF 1+ 
; ==>
;   (+ CL-PPCRE::MATCH-END 1)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (LENGTH CL-PPCRE::TARGET-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (CL-PPCRE:DO-SCANS
;    (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
;                           CL-PPCRE::REG-STARTS
;                           CL-PPCRE::REG-ENDS
;                           CL-PPCRE::REGEX
;                           CL-PPCRE::TARGET-STRING
;                           NIL
;                           :START
;                           CL-PPCRE::START
;                           :END
;                           CL-PPCRE::END)
;    (UNLESS
;        (AND (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;             (= CL-PPCRE::MATCH-START (CAR CL-PPCRE::POS-LIST)))
;      (WHEN (AND CL-PPCRE::LIMIT (>= # CL-PPCRE::LIMIT)) (RETURN))
;      (PUSH CL-PPCRE::MATCH-START CL-PPCRE::POS-LIST)
;      (WHEN CL-PPCRE::WITH-REGISTERS-P
;        (LOOP CL-PPCRE::FOR
;              CL-PPCRE::REG-START
;              CL-PPCRE::ACROSS
;              CL-PPCRE::REG-STARTS
;              CL-PPCRE::FOR
;              CL-PPCRE::REG-END
;              CL-PPCRE::ACROSS
;              CL-PPCRE::REG-ENDS
;              IF
;              CL-PPCRE::REG-START
;              DO
;              ...))
;      (PUSH CL-PPCRE::MATCH-END CL-PPCRE::POS-LIST)))
; --> LET BLOCK LET* OR LET IF OR 
; ==>
;   (LENGTH #:TARGET-STRING436)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.

;     (= CL-PPCRE::MATCH-START (CAR CL-PPCRE::POS-LIST))
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.

;     (INCF CL-PPCRE::COUNTER)
; --> LET* 
; ==>
;   (+ CL-PPCRE::COUNTER #:G446)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1)
;                               &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1)
;                               &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (>= (INCF CL-PPCRE::COUNTER) CL-PPCRE::LIMIT)
; --> IF 
; ==>
;   (< (INCF CL-PPCRE::COUNTER) CL-PPCRE::LIMIT)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

;     (CL-PPCRE:DO-SCANS
;    (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
;                           CL-PPCRE::REG-STARTS
;                           CL-PPCRE::REG-ENDS
;                           CL-PPCRE::REGEX
;                           CL-PPCRE::TARGET-STRING
;                           NIL
;                           :START
;                           CL-PPCRE::START
;                           :END
;                           CL-PPCRE::END)
;    (UNLESS
;        (AND (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
;             (= CL-PPCRE::MATCH-START (CAR CL-PPCRE::POS-LIST)))
;      (WHEN (AND CL-PPCRE::LIMIT (>= # CL-PPCRE::LIMIT)) (RETURN))
;      (PUSH CL-PPCRE::MATCH-START CL-PPCRE::POS-LIST)
;      (WHEN CL-PPCRE::WITH-REGISTERS-P
;        (LOOP CL-PPCRE::FOR
;              CL-PPCRE::REG-START
;              CL-PPCRE::ACROSS
;              CL-PPCRE::REG-STARTS
;              CL-PPCRE::FOR
;              CL-PPCRE::REG-END
;              CL-PPCRE::ACROSS
;              CL-PPCRE::REG-ENDS
;              IF
;              CL-PPCRE::REG-START
;              DO
;              ...))
;      (PUSH CL-PPCRE::MATCH-END CL-PPCRE::POS-LIST)))
; --> LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION SETQ THE IF 
; ==>
;   (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.

; --> LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION SETQ THE IF 1+ 
; ==>
;   (+ CL-PPCRE::MATCH-END 1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (> CL-PPCRE::THIS-END CL-PPCRE::THIS-START)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

; compiling (DEFINE-COMPILER-MACRO SPLIT ...)
; compiling (DEFUN STRING-CASE-MODIFIER ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN STRING-CASE-MODIFIER
;     (CHAR CL-PPCRE::STR (1- CL-PPCRE::FROM))
; --> AREF LET* 
; ==>
;   (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
; because:
;   Upgraded element type of array is not known at compile time.

;     (ALPHANUMERICP (CHAR CL-PPCRE::STR (1- CL-PPCRE::FROM)))
; --> BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (CHAR CL-PPCRE::STR CL-PPCRE::FROM)
; --> AREF LET* 
; ==>
;   (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
; because:
;   Upgraded element type of array is not known at compile time.

;     (ALPHANUMERICP (CHAR CL-PPCRE::STR CL-PPCRE::FROM))
; --> BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (CHAR CL-PPCRE::STR CL-PPCRE::TO)
; --> AREF LET* 
; ==>
;   (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
; because:
;   Upgraded element type of array is not known at compile time.

;     (CHAR CL-PPCRE::STR (1- CL-PPCRE::TO))
; --> AREF LET* 
; ==>
;   (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
; because:
;   Upgraded element type of array is not known at compile time.

;     (ALPHANUMERICP (CHAR CL-PPCRE::STR (1- CL-PPCRE::TO)))
; --> BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (CHAR CL-PPCRE::STR CL-PPCRE::INDEX)
; --> AREF LET* 
; ==>
;   (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
; because:
;   Upgraded element type of array is not known at compile time.

;     (ALPHANUMERICP (CHAR CL-PPCRE::STR CL-PPCRE::TO))
; --> BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK LET OR LET IF OR = IF 
; ==>
;   (= GC 12)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (BOTH-CASE-P CL-PPCRE::CHR)
; --> BLOCK < IF 
; ==>
;   (< (SB-IMPL::UCD-VALUE-0 CHAR) 2)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (UPPER-CASE-P CL-PPCRE::CHR)
; --> BLOCK = IF 
; ==>
;   (= (SB-IMPL::UCD-VALUE-0 CHAR) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

;     (ALPHANUMERICP (CHAR CL-PPCRE::STR (1- CL-PPCRE::FROM)))
; --> BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

;     (ALPHANUMERICP (CHAR CL-PPCRE::STR CL-PPCRE::FROM))
; --> BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

;     (ALPHANUMERICP (CHAR CL-PPCRE::STR CL-PPCRE::TO))
; --> BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

;     (ALPHANUMERICP (CHAR CL-PPCRE::STR (1- CL-PPCRE::TO)))
; --> BLOCK LET OR LET < IF 
; ==>
;   (< GC 5)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

;     (BOTH-CASE-P CL-PPCRE::CHR)
; --> BLOCK < IF 
; ==>
;   (< (SB-IMPL::UCD-VALUE-0 CHAR) 2)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; compiling (DEFGENERIC BUILD-REPLACEMENT-TEMPLATE ...)
; compiling (LET* (# #) ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFMETHOD BUILD-REPLACEMENT-TEMPLATE (STRING)
;     (SUBSEQ CL-PPCRE::REPLACEMENT-STRING CL-PPCRE::FROM)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-BASE-STRING.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY CHARACTER (*))
;                                              &REST
;                                              T).

;     (SUBSEQ CL-PPCRE::REPLACEMENT-STRING CL-PPCRE::FROM CL-PPCRE::MATCH-START)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-BASE-STRING.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY CHARACTER (*))
;                                              &REST
;                                              T).

;     (POSITION-IF #'DIGIT-CHAR-P
;                CL-PPCRE::REPLACEMENT-STRING
;                :START
;                CL-PPCRE::MATCH-START
;                :END
;                CL-PPCRE::MATCH-END)
; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%FIND-POSITION-IF
;    (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-C:PREDICATE)
;    SEQUENCE
;    SB-C::FROM-END
;    SB-C::START
;    SB-C::END
;    (SB-KERNEL:EFFECTIVE-FIND-POSITION-KEY SB-C::KEY))
; 
; note: unable to
;   expand inline
; because:
;   upgraded array element type not known at compile time

;     (CHAR CL-PPCRE::REPLACEMENT-STRING (1+ CL-PPCRE::MATCH-START))
; --> AREF LET* 
; ==>
;   (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
; because:
;   Upgraded element type of array is not known at compile time.

;     (SUBSEQ CL-PPCRE::REPLACEMENT-STRING
;           CL-PPCRE::MATCH-START
;           CL-PPCRE::MATCH-END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-BASE-STRING.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY CHARACTER (*))
;                                              &REST
;                                              T).

;     (< CL-PPCRE::FROM CL-PPCRE::MATCH-START)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a REAL, not a FIXNUM.

;     (1-
;    (PARSE-INTEGER CL-PPCRE::REPLACEMENT-STRING
;                   :START
;                   CL-PPCRE::PARSE-START
;                   :JUNK-ALLOWED
;                   T))
; ==>
;   (-
;    (PARSE-INTEGER CL-PPCRE::REPLACEMENT-STRING
;                   :START
;                   CL-PPCRE::PARSE-START
;                   :JUNK-ALLOWED
;                   T)
;    1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (< CL-PPCRE::TOKEN 0)
; 
; 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.

; compiling (DEFMETHOD BUILD-REPLACEMENT-TEMPLATE ...)
; compiling (DEFMETHOD BUILD-REPLACEMENT-TEMPLATE ...)
; compiling (DEFMETHOD BUILD-REPLACEMENT-TEMPLATE ...)
; compiling (DEFUN BUILD-REPLACEMENT ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN BUILD-REPLACEMENT
;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING
;                      CL-PPCRE::REG-START
;                      CL-PPCRE::REG-END)
; --> BLOCK MAKE-ARRAY 
; ==>
;   (- CL-PPCRE::END CL-PPCRE::START)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING
;                      CL-PPCRE::MATCH-START
;                      CL-PPCRE::MATCH-END)
; --> BLOCK MAKE-ARRAY 
; ==>
;   (- CL-PPCRE::END CL-PPCRE::START)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (ARRAY-DIMENSION CL-PPCRE::REG-STARTS 0)
; 
; note: unable to
;   optimize
; because:
;   The array dimensions are unknown; must call ARRAY-DIMENSION at runtime.

;     (MAP 'LIST
;        (LAMBDA (CL-PPCRE::REG-START CL-PPCRE::REG-END)
;          (AND CL-PPCRE::REG-START
;               (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING
;                                  CL-PPCRE::REG-START
;                                  CL-PPCRE::REG-END)))
;        CL-PPCRE::REG-STARTS
;        CL-PPCRE::REG-ENDS)
; --> TRULY-THE 
; ==>
;   (SB-KERNEL:%MAP SB-C::RESULT-TYPE-ARG SB-C::FUN #:G738 #:G739)
; 
; note: unable to open code because: can't determine sequence argument type

; ==>
;   (SB-KERNEL:%MAP SB-C::RESULT-TYPE-ARG SB-C::FUN #:G747 #:G748)
; 
; note: unable to open code because: can't determine sequence argument type

;     (>= CL-PPCRE::TOKEN CL-PPCRE::REG-BOUND)
; --> IF 
; ==>
;   (< CL-PPCRE::TOKEN CL-PPCRE::REG-BOUND)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.

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

;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING
;                      CL-PPCRE::MATCH-START
;                      CL-PPCRE::MATCH-END)
; --> BLOCK MAKE-ARRAY 
; ==>
;   (- CL-PPCRE::END CL-PPCRE::START)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING
;                      CL-PPCRE::REG-START
;                      CL-PPCRE::REG-END)
; --> BLOCK MAKE-ARRAY 
; ==>
;   (- CL-PPCRE::END CL-PPCRE::START)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; compiling (DEFUN REPLACE-AUX ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN REPLACE-AUX
;     (FUNCALL
;    (CL-PPCRE::STRING-CASE-MODIFIER CL-PPCRE::TARGET-STRING
;                                    CL-PPCRE::FROM
;                                    CL-PPCRE::TO
;                                    CL-PPCRE::START
;                                    CL-PPCRE::END)
;    CL-PPCRE::CURR-REPLACEMENT)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
;   The first argument is a (OR NULL FUNCTION), not a FUNCTION.

; compiling (DEFUN REGEX-REPLACE ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN REGEX-REPLACE
;     (SUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::START CL-PPCRE::END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY CHARACTER (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY SINGLE-FLOAT (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-BIT-VECTOR.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BIT-VECTOR &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 2)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 4)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 7)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 8)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 15)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 16)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 29) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 29)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 31)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 32)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 8) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 8) (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 16) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 16)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY FIXNUM (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES (SIMPLE-ARRAY FIXNUM (*))
;                                                     &REST
;                                                     T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 32) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 32)
;                                                            (*))
;                                              &REST
;                                              T).

;     (LENGTH CL-PPCRE::TARGET-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; compiling (DEFINE-COMPILER-MACRO REGEX-REPLACE ...)
; compiling (DEFUN REGEX-REPLACE-ALL ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN REGEX-REPLACE-ALL
;     (SUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::START CL-PPCRE::END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY CHARACTER (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY SINGLE-FLOAT (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-BIT-VECTOR.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BIT-VECTOR &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 2)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 4)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 7)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 8)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 15)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 16)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 29) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 29)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 31)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 32)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 8) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 8) (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 16) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 16)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY FIXNUM (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES (SIMPLE-ARRAY FIXNUM (*))
;                                                     &REST
;                                                     T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 32) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 32)
;                                                            (*))
;                                              &REST
;                                              T).

;     (CL-PPCRE:DO-SCANS
;    (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
;                           CL-PPCRE::REG-STARTS
;                           CL-PPCRE::REG-ENDS
;                           CL-PPCRE::REGEX
;                           CL-PPCRE::TARGET-STRING
;                           NIL
;                           :START
;                           CL-PPCRE::START
;                           :END
;                           CL-PPCRE::END)
;    (PUSH CL-PPCRE::MATCH-START CL-PPCRE::POS-LIST)
;    (PUSH CL-PPCRE::MATCH-END CL-PPCRE::POS-LIST)
;    (PUSH CL-PPCRE::REG-STARTS CL-PPCRE::REG-LIST)
;    (PUSH CL-PPCRE::REG-ENDS CL-PPCRE::REG-LIST))
; --> LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION SETQ THE IF 
; ==>
;   (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; --> LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION SETQ THE IF 1+ 
; ==>
;   (+ CL-PPCRE::MATCH-END 1)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (LENGTH CL-PPCRE::TARGET-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (CL-PPCRE:DO-SCANS
;    (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
;                           CL-PPCRE::REG-STARTS
;                           CL-PPCRE::REG-ENDS
;                           CL-PPCRE::REGEX
;                           CL-PPCRE::TARGET-STRING
;                           NIL
;                           :START
;                           CL-PPCRE::START
;                           :END
;                           CL-PPCRE::END)
;    (PUSH CL-PPCRE::MATCH-START CL-PPCRE::POS-LIST)
;    (PUSH CL-PPCRE::MATCH-END CL-PPCRE::POS-LIST)
;    (PUSH CL-PPCRE::REG-STARTS CL-PPCRE::REG-LIST)
;    (PUSH CL-PPCRE::REG-ENDS CL-PPCRE::REG-LIST))
; --> LET BLOCK LET* OR LET IF OR 
; ==>
;   (LENGTH #:TARGET-STRING839)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION SETQ THE IF 
; ==>
;   (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.

; --> LET BLOCK LET* BLOCK TAGBODY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION SETQ THE IF 1+ 
; ==>
;   (+ CL-PPCRE::MATCH-END 1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; compiling (DEFINE-COMPILER-MACRO REGEX-REPLACE-ALL ...)
; compiling (DEFMACRO REGEX-APROPOS-AUX ...)
; compiling (DEFUN REGEX-APROPOS-LIST ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN REGEX-APROPOS-LIST
;     (DEFUN CL-PPCRE:REGEX-APROPOS-LIST
;          (CL-PPCRE::REGEX
;           &OPTIONAL CL-PPCRE::PACKAGES
;           &KEY (CL-PPCRE::CASE-INSENSITIVE T))
;     (DECLARE
;      (OPTIMIZE SPEED (SAFETY 0) (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
;     "Similar to the standard function APROPOS-LIST but returns a list of
; all symbols which match the regular expression REGEX. If
; CASE-INSENSITIVE is true and REGEX isn't already a scanner, a
; case-insensitive scanner is used."
;     (LET ((CL-PPCRE::COLLECTOR 'NIL))
;       (CL-PPCRE::REGEX-APROPOS-AUX
;        (CL-PPCRE::REGEX CL-PPCRE::PACKAGES
;                         CL-PPCRE::CASE-INSENSITIVE
;                         CL-PPCRE::COLLECTOR)
;        (PUSH SYMBOL CL-PPCRE::COLLECTOR))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-PPCRE:REGEX-APROPOS-LIST
;                          (CL-PPCRE::REGEX &OPTIONAL
;                                           CL-PPCRE::PACKAGES
;                                           &KEY
;                                           (CL-PPCRE::CASE-INSENSITIVE T))
;                          (DECLARE
;                           (OPTIMIZE SPEED
;                                     (SAFETY 0)
;                                     (SPACE 0)
;                                     (DEBUG 1)
;                                     (COMPILATION-SPEED 0)))
;                          (BLOCK CL-PPCRE:REGEX-APROPOS-LIST
;                            (LET ((CL-PPCRE::COLLECTOR 'NIL))
;                              (CL-PPCRE::REGEX-APROPOS-AUX
;                               (CL-PPCRE::REGEX CL-PPCRE::PACKAGES
;                                                CL-PPCRE::CASE-INSENSITIVE
;                                                CL-PPCRE::COLLECTOR)
;                               (PUSH SYMBOL CL-PPCRE::COLLECTOR)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (REGEX &OPTIONAL
;                                                            PACKAGES
;                                                            &KEY
;                                                            (CASE-INSENSITIVE T))
; in: LAMBDA (#:WHOLE919 #:ENVIRONMENT920)
;     (MEMBER SB-IMPL::THIS-KIND '(:INTERNAL :EXTERNAL :INHERITED))
; --> BLOCK LET DO BLOCK LET TAGBODY TAGBODY LET IF SB-IMPL::SATISFIES-THE-TEST 
; --> LET COND IF COND IF COND IF PROGN FUNCALL 
; ==>
;   (SB-C::%FUNCALL FUNCTION #:G26 #:G27)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a SINGLE-FLOAT.
;   The second argument is a T, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a DOUBLE-FLOAT.
;   The second argument is a T, not a DOUBLE-FLOAT.
; 
; note: forced to do GENERIC-EQL (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.

; compiling (DEFUN PRINT-SYMBOL-INFO ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN PRINT-SYMBOL-INFO
;     (FORMAT T "~&~S ~<~;~^~A~@{~:@_~A~}~;~:>" SYMBOL CL-PPCRE::OUTPUT-LIST)
; --> FORMAT FORMATTER FUNCTION BLOCK LET PPRINT-LOGICAL-BLOCK 
; --> SB-PRETTY::WITH-PRETTY-STREAM FLET BLOCK LET IF 
; --> SB-KERNEL:WITH-CIRCULARITY-DETECTION LABELS BLOCK SB-KERNEL:DESCEND-INTO 
; --> FLET COND IF AND IF AND IF AND >= IF 
; ==>
;   (< SB-KERNEL:*CURRENT-LEVEL-IN-PRINT* *PRINT-LEVEL*)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> FORMAT FORMATTER FUNCTION BLOCK LET PPRINT-LOGICAL-BLOCK 
; --> SB-PRETTY::WITH-PRETTY-STREAM FLET BLOCK LET IF 
; --> SB-KERNEL:WITH-CIRCULARITY-DETECTION LABELS BLOCK SB-KERNEL:DESCEND-INTO 
; --> FLET COND IF COND IF PROGN LET 1+ 
; ==>
;   (+ SB-KERNEL:*CURRENT-LEVEL-IN-PRINT* 1)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

; --> FORMAT FORMATTER FUNCTION BLOCK LET PPRINT-LOGICAL-BLOCK 
; --> SB-PRETTY::WITH-PRETTY-STREAM 
; ==>
;   (FLET ((#:WITH-PRETTY-STREAM-1399 (STREAM)
;            (LET (#)
;              (IF # # #))))
;     (LET ((STREAM
;            (LET #
;              #)))
;       (IF (SB-PRETTY:PRETTY-STREAM-P STREAM)
;           (#:WITH-PRETTY-STREAM-1399 STREAM)
;           (CATCH 'SB-PRETTY::LINE-LIMIT-ABBREVIATION-HAPPENED
;             (LET #
;               #
;               #))))
;     NIL)
; 
; note: Return type not fixed values, so can't use known return convention:
;   *

; --> FORMAT FORMATTER FUNCTION BLOCK LET PPRINT-LOGICAL-BLOCK 
; --> SB-PRETTY::WITH-PRETTY-STREAM FLET BLOCK LET IF 
; --> SB-KERNEL:WITH-CIRCULARITY-DETECTION LABELS BLOCK SB-KERNEL:DESCEND-INTO 
; --> FLET BLOCK LET BLOCK FLET BLOCK WHEN COND IF AND IF AND 
; ==>
;   (EQL #:PPRINT-LOGICAL-BLOCK-LENGTH-1397 *PRINT-LENGTH*)
; 
; note: forced to do GENERIC-EQL (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a (OR UNSIGNED-BYTE NULL), not a FIXNUM.

; --> FORMAT FORMATTER FUNCTION BLOCK LET PPRINT-LOGICAL-BLOCK 
; --> SB-PRETTY::WITH-PRETTY-STREAM FLET BLOCK LET IF 
; --> SB-KERNEL:WITH-CIRCULARITY-DETECTION LABELS BLOCK SB-KERNEL:DESCEND-INTO 
; --> FLET COND IF AND IF AND IF AND >= IF 
; ==>
;   (< SB-KERNEL:*CURRENT-LEVEL-IN-PRINT* *PRINT-LEVEL*)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.

; --> FORMAT FORMATTER FUNCTION BLOCK LET PPRINT-LOGICAL-BLOCK 
; --> SB-PRETTY::WITH-PRETTY-STREAM FLET BLOCK LET IF 
; --> SB-KERNEL:WITH-CIRCULARITY-DETECTION LABELS BLOCK SB-KERNEL:DESCEND-INTO 
; --> FLET COND IF COND IF PROGN LET 1+ 
; ==>
;   (+ SB-KERNEL:*CURRENT-LEVEL-IN-PRINT* 1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; compiling (DEFUN REGEX-APROPOS ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.lisp
; in: DEFUN REGEX-APROPOS
;     (DEFUN CL-PPCRE:REGEX-APROPOS
;          (CL-PPCRE::REGEX
;           &OPTIONAL CL-PPCRE::PACKAGES
;           &KEY (CL-PPCRE::CASE-INSENSITIVE T))
;     "Similar to the standard function APROPOS but returns a list of all
; symbols which match the regular expression REGEX. If CASE-INSENSITIVE
; is true and REGEX isn't already a scanner, a case-insensitive scanner
; is used."
;     (DECLARE
;      (OPTIMIZE SPEED (SAFETY 0) (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
;     (CL-PPCRE::REGEX-APROPOS-AUX
;      (CL-PPCRE::REGEX CL-PPCRE::PACKAGES CL-PPCRE::CASE-INSENSITIVE)
;      (CL-PPCRE::PRINT-SYMBOL-INFO SYMBOL))
;     (VALUES))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-PPCRE:REGEX-APROPOS
;                          (CL-PPCRE::REGEX &OPTIONAL
;                                           CL-PPCRE::PACKAGES
;                                           &KEY
;                                           (CL-PPCRE::CASE-INSENSITIVE T))
;                          (DECLARE
;                           (OPTIMIZE SPEED
;                                     (SAFETY 0)
;                                     (SPACE 0)
;                                     (DEBUG 1)
;                                     (COMPILATION-SPEED 0)))
;                          (BLOCK CL-PPCRE:REGEX-APROPOS
;                            (CL-PPCRE::REGEX-APROPOS-AUX
;                             (CL-PPCRE::REGEX CL-PPCRE::PACKAGES
;                                              CL-PPCRE::CASE-INSENSITIVE)
;                             (CL-PPCRE::PRINT-SYMBOL-INFO SYMBOL))
;                            (VALUES)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (REGEX &OPTIONAL
;                                                            PACKAGES
;                                                            &KEY
;                                                            (CASE-INSENSITIVE T))
; in: LAMBDA (#:WHOLE1465 #:ENVIRONMENT1466)
;     (MEMBER SB-IMPL::THIS-KIND '(:INTERNAL :EXTERNAL :INHERITED))
; --> BLOCK LET DO BLOCK LET TAGBODY TAGBODY LET IF SB-IMPL::SATISFIES-THE-TEST 
; --> LET COND IF COND IF COND IF PROGN FUNCALL 
; ==>
;   (SB-C::%FUNCALL FUNCTION #:G26 #:G27)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a SINGLE-FLOAT.
;   The second argument is a T, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a DOUBLE-FLOAT.
;   The second argument is a T, not a DOUBLE-FLOAT.
; 
; note: forced to do GENERIC-EQL (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.

; compiling (LET* (# #) ...)
; compiling (LET* (# # ...) ...)
; compiling (LET* (# # ...) ...)
; compiling (DEFUN PARSE-TREE-SYNONYM ...)
; compiling (DEFUN (SETF PARSE-TREE-SYNONYM) ...)
; compiling (DEFMACRO DEFINE-PARSE-TREE-SYNONYM ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-ppcre-1.2.13/api.fasl written
; compilation finished in 0:00:05
WARNING:
   COMPILE-FILE warned while performing #<COMPILE-OP NIL {40008539}> on
   #<CL-SOURCE-FILE "api" {40008549}>.
; 
; compilation unit finished
;   caught 2 STYLE-WARNING conditions
;   printed 713 notes
;;; ASDF-INSTALL: Downloading package PURI, required by acl-compat

;;; ASDF-INSTALL: Downloading 31029 bytes from http://files.b9.com/puri/puri-latest.tar.gz to /Users/gwking/temporary/asdf-test/puri.asdf-install-tmp ...

;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/puri.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
puri-1.4/
puri-1.4/uri.html
puri-1.4/tests.lisp
puri-1.4/LICENSE
puri-1.4/puri.asd
puri-1.4/README
puri-1.4/src.lisp

#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/" 
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/" 
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/src.lisp" (written 26 JAN 2006 10:18:48 PM):
; compiling (DEFPACKAGE #:PURI ...)
; compiling (IN-PACKAGE #:PURI)
; compiling (DEFUN PARSE-BODY ...)
; compiling (DEFUN SHRINK-VECTOR ...)
; compiling (DEFINE-CONDITION URI-PARSE-ERROR ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/src.lisp
; in: DEFINE-CONDITION URI-PARSE-ERROR
;     (FORMAT STREAM "Parse error:")
; ==>
;   (FORMAT SB-C::DEST (FORMATTER "Parse error:"))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (MEMBER T NIL)
;                               STREAM
;                               (VECTOR CHARACTER)
;                               (VECTOR NIL)
;                               BASE-STRING), not a STREAM.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (MEMBER T NIL)
;                               STREAM
;                               (VECTOR CHARACTER)
;                               (VECTOR NIL)
;                               BASE-STRING), not a (MEMBER T).

; compiling (DEFUN .PARSE-ERROR ...)
; compiling (DEFUN INTERNAL-READER-ERROR ...)
; compiling (DEFVAR *CURRENT-CASE-MODE* ...)
; compiling (DEFMETHOD POSITION-CHAR ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/src.lisp
; in: DEFMETHOD POSITION-CHAR (T STRING T T)
;     (CHAR STRING PURI::I)
; --> AREF LET* 
; ==>
;   (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
; because:
;   Upgraded element type of array is not known at compile time.

; compiling (DEFUN DELIMITED-STRING-TO-LIST ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/src.lisp
; in: DEFUN DELIMITED-STRING-TO-LIST
;     (SUBSEQ STRING PURI::POS PURI::END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-BASE-STRING.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY CHARACTER (*))
;                                              &REST
;                                              T).

;     (SUBSEQ STRING PURI::POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-BASE-STRING.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY CHARACTER (*))
;                                              &REST
;                                              T).

; compiling (DEFVAR IF*-KEYWORD-LIST ...)
; compiling (DEFMACRO IF* ...)
; compiling (DEFCLASS URI ...)
; compiling (DEFCLASS URN ...)
; compiling (CLEAR-CACHING-ON-SLOT-CHANGE URI-SCHEME)
; compiling (CLEAR-CACHING-ON-SLOT-CHANGE URI-HOST)
; compiling (CLEAR-CACHING-ON-SLOT-CHANGE URI-PORT)
; compiling (CLEAR-CACHING-ON-SLOT-CHANGE URI-PATH)
; compiling (CLEAR-CACHING-ON-SLOT-CHANGE URI-QUERY)
; compiling (CLEAR-CACHING-ON-SLOT-CHANGE URI-FRAGMENT)
; compiling (DEFMETHOD MAKE-LOAD-FORM ...)
; compiling (DEFMETHOD URI-P ...)
; compiling (DEFMETHOD URI-P ...)
; compiling (DEFUN COPY-URI ...)
; compiling (DEFMETHOD URI-PARSED-PATH ...)
; compiling (DEFMETHOD (SETF URI-PARSED-PATH) ...)
; compiling (DEFUN URI-AUTHORITY ...)
; compiling (DEFUN URI-NID ...)
; compiling (DEFUN URI-NSS ...)
; compiling (DEFPARAMETER *EXCLUDED-CHARACTERS* ...)
; compiling (DEFUN RESERVED-CHAR-VECTOR ...)
; compiling (DEFPARAMETER *RESERVED-CHARACTERS* ...)
; compiling (DEFPARAMETER *RESERVED-AUTHORITY-CHARACTERS* ...)
; compiling (DEFPARAMETER *RESERVED-PATH-CHARACTERS* ...)
; compiling (DEFPARAMETER *RESERVED-PATH-CHARACTERS2* ...)
; compiling (DEFPARAMETER *RESERVED-FRAGMENT-CHARACTERS* ...)
; compiling (DEFPARAMETER *VALID-NID-CHARACTERS* ...)
; compiling (DEFPARAMETER *RESERVED-NSS-CHARACTERS* ...)
; compiling (DEFPARAMETER *ILLEGAL-CHARACTERS* ...)
; compiling (DEFPARAMETER *STRICT-ILLEGAL-QUERY-CHARACTERS* ...)
; compiling (DEFPARAMETER *ILLEGAL-QUERY-CHARACTERS* ...)
; compiling (DEFUN PARSE-URI ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/src.lisp
; in: DEFUN PARSE-URI
;     (FUNCALL
;    (CASE PURI::*CURRENT-CASE-MODE*
;      ((:CASE-INSENSITIVE-UPPER :CASE-SENSITIVE-UPPER) #'STRING-UPCASE)
;      ((:CASE-INSENSITIVE-LOWER :CASE-SENSITIVE-LOWER) #'STRING-DOWNCASE))
;    (PURI::DECODE-ESCAPED-ENCODING PURI::SCHEME PURI::ESCAPE))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
;   The first argument is a (OR
;                            (FUNCTION
;                             ((OR (VECTOR CHARACTER)
;                                  (VECTOR NIL)
;                                  BASE-STRING
;                                  SYMBOL
;                                  CHARACTER)
;                              &KEY (:START (MOD 536870911)) (:END (OR NULL #)))
;                             (VALUES SIMPLE-STRING &OPTIONAL))
;                            NULL), not a FUNCTION.

;     (PLUSP PURI::PORT)
; ==>
;   (> PURI::PORT 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

; compiling (DEFMETHOD URI ...)
; compiling (DEFMETHOD URI ...)
; compiling (DEFMETHOD URI ...)
; compiling (DEFVAR *STRICT-PARSE* ...)
; compiling (DEFUN PARSE-URI-STRING ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/src.lisp
; in: DEFUN PARSE-URI-STRING
;     (LENGTH STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (CHAR STRING PURI::START)
; --> AREF LET* 
; ==>
;   (ARRAY-DIMENSION ARRAY 0)
; 
; note: unable to optimize because: can't tell whether array is simple

; ==>
;   (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
; because:
;   Upgraded element type of array is not known at compile time.

;     (SUBSEQ STRING PURI::SINDEX PURI::START)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY CHARACTER (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY SINGLE-FLOAT (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-BIT-VECTOR.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BIT-VECTOR &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 2)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 4)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 7)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 8)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 15)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 16)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 29) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 29)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 31)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 32)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 8) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 8) (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 16) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 16)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY FIXNUM (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES (SIMPLE-ARRAY FIXNUM (*))
;                                                     &REST
;                                                     T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 32) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 32)
;                                                            (*))
;                                              &REST
;                                              T).

;     (INCF PURI::START)
; --> LET* SETQ 
; ==>
;   (THE #<SB-KERNEL:NUMERIC-TYPE FIXNUM> #:G1010)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first argument of CHECK-FIXNUM

; ==>
;   (THE #<SB-KERNEL:NUMERIC-TYPE FIXNUM> #:G1008)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first argument of CHECK-FIXNUM

; compiling (DEFUN ESCAPE-P ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/src.lisp
; in: DEFUN ESCAPE-P
;     (LENGTH STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (CHAR STRING PURI::I)
; --> AREF LET* 
; ==>
;   (ARRAY-DIMENSION ARRAY 0)
; 
; note: unable to optimize because: can't tell whether array is simple

; ==>
;   (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
; because:
;   Upgraded element type of array is not known at compile time.

; compiling (DEFUN PARSE-PATH ...)
; compiling (DEFUN DECODE-ESCAPED-ENCODING ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/src.lisp
; in: DEFUN DECODE-ESCAPED-ENCODING
;     (LENGTH STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (COPY-SEQ STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY CHARACTER (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY SINGLE-FLOAT (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-BIT-VECTOR.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BIT-VECTOR &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 2)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 4)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 7)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 8)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 15)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 16)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 29) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 29)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 31)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 32)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 8) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 8) (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 16) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 16)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY FIXNUM (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES (SIMPLE-ARRAY FIXNUM (*))
;                                                     &REST
;                                                     T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 32) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 32)
;                                                            (*))
;                                              &REST
;                                              T).

;     (= PURI::I MAX)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

;     (CHAR STRING PURI::I)
; --> AREF LET* 
; ==>
;   (ARRAY-DIMENSION ARRAY 0)
; 
; note: unable to optimize because: can't tell whether array is simple

; ==>
;   (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
; because:
;   Upgraded element type of array is not known at compile time.

;     (CHAR STRING (INCF PURI::I))
; --> AREF LET* 
; ==>
;   (ARRAY-DIMENSION ARRAY 0)
; 
; note: unable to optimize because: can't tell whether array is simple

; ==>
;   (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
; because:
;   Upgraded element type of array is not known at compile time.

; ==>
;   (ARRAY-DIMENSION ARRAY 0)
; 
; note: unable to optimize because: can't tell whether array is simple

; ==>
;   (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
; because:
;   Upgraded element type of array is not known at compile time.

;     (LENGTH PURI::RESERVED-CHARS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (1+ PURI::I)
; ==>
;   (+ PURI::I 1)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (1+ PURI::NEW-I)
; ==>
;   (+ PURI::NEW-I 1)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

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

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

;     (INCF PURI::I)
; --> LET* 
; ==>
;   (+ PURI::I #:G1149)
; 
; note: doing unsigned word to integer coercion (cost 20), for:
;       the first result of inline (unsigned-byte 32) arithmetic

;     (INCF PURI::NEW-I)
; --> LET* 
; ==>
;   (+ PURI::NEW-I #:G1161)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first result of inline (signed-byte 32) arithmetic

; ==>
;   (+ PURI::NEW-I #:G1166)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first result of inline (signed-byte 32) arithmetic

; compiling (DEFUN RENDER-URI ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/src.lisp
; in: DEFUN RENDER-URI
;     (FORMAT STREAM "~a" (PURI::URI-STRING PURI:URI))
; ==>
;   (FORMAT SB-C::DEST (FORMATTER "~a") #:G1205)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (MEMBER T NIL)
;                               STREAM
;                               (VECTOR CHARACTER)
;                               (VECTOR NIL)
;                               BASE-STRING), not a STREAM.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (MEMBER T NIL)
;                               STREAM
;                               (VECTOR CHARACTER)
;                               (VECTOR NIL)
;                               BASE-STRING), not a (MEMBER T).

; compiling (DEFUN RENDER-PARSED-PATH ...)
; compiling (DEFUN RENDER-URN ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/src.lisp
; in: DEFUN RENDER-URN
;     (FORMAT STREAM "~a" (PURI::URI-STRING PURI:URN))
; ==>
;   (FORMAT SB-C::DEST (FORMATTER "~a") #:G1243)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (MEMBER T NIL)
;                               STREAM
;                               (VECTOR CHARACTER)
;                               (VECTOR NIL)
;                               BASE-STRING), not a STREAM.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (MEMBER T NIL)
;                               STREAM
;                               (VECTOR CHARACTER)
;                               (VECTOR NIL)
;                               BASE-STRING), not a (MEMBER T).

; compiling (DEFPARAMETER *ESCAPED-ENCODING* ...)
; compiling (DEFUN ENCODE-ESCAPED-ENCODING ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/src.lisp
; in: DEFUN ENCODE-ESCAPED-ENCODING
;     (LENGTH STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (CHAR STRING PURI::I)
; --> AREF LET* 
; ==>
;   (ARRAY-DIMENSION ARRAY 0)
; 
; note: unable to optimize because: can't tell whether array is simple

; ==>
;   (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
; because:
;   Upgraded element type of array is not known at compile time.

;     (INCF PURI::NEW-I)
; --> LET* 
; ==>
;   (+ PURI::NEW-I #:G1387)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

; ==>
;   (+ PURI::NEW-I #:G1396)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

; ==>
;   (+ PURI::NEW-I #:G1401)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (ELT PURI::*ESCAPED-ENCODING* PURI::Q)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.

;     (INCF PURI::NEW-I)
; --> LET* 
; ==>
;   (+ PURI::NEW-I #:G1406)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (ELT PURI::*ESCAPED-ENCODING* PURI::R)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.

;     (INCF PURI::NEW-I)
; --> LET* 
; ==>
;   (+ PURI::NEW-I #:G1410)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (+ PURI::NEW-I #:G1396)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (+ PURI::NEW-I #:G1401)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (+ PURI::NEW-I #:G1406)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (+ PURI::NEW-I #:G1387)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (MAKE-STRING PURI::NEW-MAX)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first argument of CHECK-FIXNUM

; compiling (DEFMETHOD PRINT-OBJECT ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/src.lisp
; in: DEFMETHOD PRINT-OBJECT (URI T)
;     (FORMAT STREAM "#<~a ~a>" 'PURI:URI (PURI:RENDER-URI PURI:URI NIL))
; ==>
;   (FORMAT SB-C::DEST (FORMATTER "#<~a ~a>") #:G1485 #:G1486)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (MEMBER T NIL)
;                               STREAM
;                               (VECTOR CHARACTER)
;                               (VECTOR NIL)
;                               BASE-STRING), not a STREAM.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (MEMBER T NIL)
;                               STREAM
;                               (VECTOR CHARACTER)
;                               (VECTOR NIL)
;                               BASE-STRING), not a (MEMBER T).

; compiling (DEFMETHOD PRINT-OBJECT ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/src.lisp
; in: DEFMETHOD PRINT-OBJECT (URN T)
;     (FORMAT STREAM "#<~a ~a>" 'PURI:URI (PURI::RENDER-URN PURI:URN NIL))
; ==>
;   (FORMAT SB-C::DEST (FORMATTER "#<~a ~a>") #:G1525 #:G1526)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (MEMBER T NIL)
;                               STREAM
;                               (VECTOR CHARACTER)
;                               (VECTOR NIL)
;                               BASE-STRING), not a STREAM.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (MEMBER T NIL)
;                               STREAM
;                               (VECTOR CHARACTER)
;                               (VECTOR NIL)
;                               BASE-STRING), not a (MEMBER T).

; compiling (DEFMETHOD MERGE-URIS ...)
; compiling (DEFMETHOD MERGE-URIS ...)
; compiling (DEFMETHOD MERGE-URIS ...)
; compiling (DEFMETHOD MERGE-URIS ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/src.lisp
; in: DEFMETHOD MERGE-URIS (URI URI)
;     (STRING= PURI::A
;            (PURI::IF* (ATOM PURI::B)
;                       PURI::THEN
;                       PURI::B
;                       PURI::ELSE
;                       (CAR PURI::B)))
; ==>
;   (SB-KERNEL:STRING=* SB-C::STRING1
;                       SB-C::STRING2
;                       SB-C::START1
;                       SB-C::END1
;                       SB-C::START2
;                       SB-C::END2)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (VECTOR CHARACTER)
;                               (VECTOR NIL)
;                               BASE-STRING
;                               SYMBOL
;                               CHARACTER), not a SIMPLE-BASE-STRING.
;   The second argument is a (OR (VECTOR CHARACTER)
;                                (VECTOR NIL)
;                                BASE-STRING
;                                SYMBOL
;                                CHARACTER), not a SIMPLE-BASE-STRING.

;     (POSITION ".."
;             PURI::NPL
;             :TEST
;             #'(LAMBDA (PURI::A PURI::B)
;                 (STRING= PURI::A
;                          (PURI::IF* (ATOM PURI::B)
;                                     PURI::THEN
;                                     PURI::B
;                                     PURI::ELSE
;                                     (CAR PURI::B)))))
; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%FIND-POSITION SB-C::ITEM
;                             SEQUENCE
;                             SB-C::FROM-END
;                             SB-C::START
;                             SB-C::END
;                             (SB-KERNEL:EFFECTIVE-FIND-POSITION-KEY SB-C::KEY)
;                             (SB-KERNEL:EFFECTIVE-FIND-POSITION-TEST SB-C::TEST
;                                                                     SB-C::TEST-NOT))
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a VECTOR.

;     (STRING= PURI::A PURI::B)
; ==>
;   (SB-KERNEL:STRING=* SB-C::STRING1
;                       SB-C::STRING2
;                       SB-C::START1
;                       SB-C::END1
;                       SB-C::START2
;                       SB-C::END2)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (VECTOR CHARACTER)
;                               (VECTOR NIL)
;                               BASE-STRING
;                               SYMBOL
;                               CHARACTER), not a SIMPLE-BASE-STRING.
;   The second argument is a (OR (VECTOR CHARACTER)
;                                (VECTOR NIL)
;                                BASE-STRING
;                                SYMBOL
;                                CHARACTER), not a SIMPLE-BASE-STRING.

; compiling (DEFMETHOD ENOUGH-URI ...)
; compiling (DEFMETHOD ENOUGH-URI ...)
; compiling (DEFMETHOD ENOUGH-URI ...)
; compiling (DEFMETHOD ENOUGH-URI ...)
; compiling (DEFUN MAKE-URI-SPACE ...)
; compiling (DEFUN GETHASH-URI ...)
; compiling (DEFUN PUTHASH-URI ...)
; compiling (DEFUN URI-HASH ...)
; compiling (DEFVAR *URIS* ...)
; compiling (DEFUN URI-SPACE ...)
; compiling (DEFUN (SETF URI-SPACE) ...)
; compiling (WHEN (FBOUNDP #) ...)
; compiling (DEFGENERIC URI= ...)
; compiling (DEFMETHOD URI= ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/src.lisp
; in: DEFMETHOD URI= (URI URI)
;     (EQL (OR (PURI:URI-PORT PURI::URI1) PURI::DEFAULT-PORT)
;        (OR (PURI:URI-PORT PURI::URI2) PURI::DEFAULT-PORT))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a SINGLE-FLOAT.
;   The second argument is a T, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a DOUBLE-FLOAT.
;   The second argument is a T, not a DOUBLE-FLOAT.

;     (STRING= (PURI:URI-PATH PURI::URI1) (PURI:URI-PATH PURI::URI2))
; ==>
;   (SB-KERNEL:STRING=* SB-C::STRING1
;                       SB-C::STRING2
;                       SB-C::START1
;                       SB-C::END1
;                       SB-C::START2
;                       SB-C::END2)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (VECTOR CHARACTER)
;                               (VECTOR NIL)
;                               BASE-STRING
;                               SYMBOL
;                               CHARACTER), not a SIMPLE-BASE-STRING.
;   The second argument is a (OR (VECTOR CHARACTER)
;                                (VECTOR NIL)
;                                BASE-STRING
;                                SYMBOL
;                                CHARACTER), not a SIMPLE-BASE-STRING.

;     (STRING= (PURI:URI-QUERY PURI::URI1) (PURI:URI-QUERY PURI::URI2))
; ==>
;   (SB-KERNEL:STRING=* SB-C::STRING1
;                       SB-C::STRING2
;                       SB-C::START1
;                       SB-C::END1
;                       SB-C::START2
;                       SB-C::END2)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (VECTOR CHARACTER)
;                               (VECTOR NIL)
;                               BASE-STRING
;                               SYMBOL
;                               CHARACTER), not a SIMPLE-BASE-STRING.
;   The second argument is a (OR (VECTOR CHARACTER)
;                                (VECTOR NIL)
;                                BASE-STRING
;                                SYMBOL
;                                CHARACTER), not a SIMPLE-BASE-STRING.

;     (STRING= (PURI:URI-FRAGMENT PURI::URI1) (PURI:URI-FRAGMENT PURI::URI2))
; ==>
;   (SB-KERNEL:STRING=* SB-C::STRING1
;                       SB-C::STRING2
;                       SB-C::START1
;                       SB-C::END1
;                       SB-C::START2
;                       SB-C::END2)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (VECTOR CHARACTER)
;                               (VECTOR NIL)
;                               BASE-STRING
;                               SYMBOL
;                               CHARACTER), not a SIMPLE-BASE-STRING.
;   The second argument is a (OR (VECTOR CHARACTER)
;                                (VECTOR NIL)
;                                BASE-STRING
;                                SYMBOL
;                                CHARACTER), not a SIMPLE-BASE-STRING.

;     (EQL (OR (PURI:URI-PORT PURI::URI1) PURI::DEFAULT-PORT)
;        (OR (PURI:URI-PORT PURI::URI2) PURI::DEFAULT-PORT))
; 
; note: forced to do GENERIC-EQL (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.

; compiling (DEFMETHOD URI= ...)
; compiling (DEFUN URN-NSS-EQUAL ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/src.lisp
; in: DEFUN URN-NSS-EQUAL
;     (LENGTH PURI::NSS1)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (LENGTH PURI::NSS2)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (CHAR PURI::NSS1 PURI::I)
; --> AREF LET* 
; ==>
;   (ARRAY-DIMENSION ARRAY 0)
; 
; note: unable to optimize because: can't tell whether array is simple

; ==>
;   (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
; because:
;   Upgraded element type of array is not known at compile time.

;     (CHAR PURI::NSS2 PURI::I)
; --> AREF LET* 
; ==>
;   (ARRAY-DIMENSION ARRAY 0)
; 
; note: unable to optimize because: can't tell whether array is simple

; ==>
;   (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
; because:
;   Upgraded element type of array is not known at compile time.

;     (CHAR-NOT-EQUAL PURI::C1 PURI::C2)
; --> IF 
; ==>
;   (CHAR-EQUAL PURI::C1 PURI::C2)
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.

; compiling (DEFMETHOD INTERN-URI ...)
; compiling (DEFMETHOD INTERN-URI ...)
; compiling (DEFUN UNINTERN-URI ...)
; compiling (DEFMACRO DO-ALL-URIS ...)
; compiling (DEFUN SHARP-U ...)
; compiling (SET-DISPATCH-MACRO-CHARACTER #\# ...)
; compiling (PROVIDE :URI)
; compiling (DEFUN GC ...)
; compiling (DEFUN TIME-URI-MODULE ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/puri-1.4/src.fasl written
; compilation finished in 0:00:05
STYLE-WARNING: implicitly creating new generic function POSITION-CHAR
STYLE-WARNING: implicitly creating new generic function URI-P
STYLE-WARNING: implicitly creating new generic function URI-PARSED-PATH
STYLE-WARNING: implicitly creating new generic function (SETF URI-PARSED-PATH)
STYLE-WARNING: implicitly creating new generic function URI
STYLE-WARNING: implicitly creating new generic function MERGE-URIS
STYLE-WARNING: implicitly creating new generic function ENOUGH-URI
STYLE-WARNING: implicitly creating new generic function INTERN-URI
; 
; compilation unit finished
;   printed 145 notes
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/packages.lisp" (written 05 SEP 2004 08:27:26 AM):
; compiling (IN-PACKAGE :COMMON-LISP-USER)
; compiling (DEFPACKAGE :ACL-COMPAT.EXCL ...)
; compiling (DEFPACKAGE :ACL-COMPAT.MP ...)
; compiling (DEFPACKAGE :DE.DATAHEAVEN.CHUNKED-STREAM-MIXIN ...)
; compiling (DEFPACKAGE ACL-COMPAT.SOCKET ...)
; compiling (DEFPACKAGE ACL-COMPAT.SYSTEM ...)
; compiling (DEFPACKAGE :GRAY-STREAM ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/packages.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/lw-buffering.lisp" (written 15 DEC 2003 10:10:41 AM):
; compiling (IN-PACKAGE :GRAY-STREAM)
; compiling (DEFVAR *DEFAULT-INPUT-BUFFER-SIZE* ...)
; compiling (DEFVAR *DEFAULT-OUTPUT-BUFFER-SIZE* ...)
; compiling (DEFSTRUCT BUFFER-STATE ...)
; compiling (DEFUN %ALLOCATE-BUFFER-STATE ...)
; compiling (DEFUN %DEALLOCATE-BUFFER-STATE ...)
; compiling (DEFCLASS NATIVE-LISP-STREAM-MIXIN ...)
; compiling (DEFCLASS BUFFERED-STREAM-MIXIN ...)
; compiling (DEFCLASS FUNDAMENTAL-BIVALENT-INPUT-STREAM ...)
; compiling (DEFCLASS FUNDAMENTAL-BIVALENT-OUTPUT-STREAM ...)
; compiling (DEFCLASS BUFFERED-BIVALENT-INPUT-STREAM ...)
; compiling (DEFCLASS BUFFERED-BIVALENT-OUTPUT-STREAM ...)
; compiling (DEFCLASS BUFFERED-BIVALENT-STREAM ...)
; compiling (DEFMACRO WITH-STREAM-OUTPUT-BUFFER ...)
; compiling (DEFMETHOD CLOSE ...)
; compiling (DEFMETHOD STREAM-LISTEN ...)
; compiling (DEFMETHOD OPEN-STREAM-P ...)
; compiling (DEFMETHOD STREAM-CLEAR-OUTPUT ...)
; compiling (DECLAIM (INLINE %READER-FUNCTION-FOR-SEQUENCE))
; compiling (DEFUN %READER-FUNCTION-FOR-SEQUENCE ...)
; compiling (DEFUN READ-ELEMENTS ...)
; compiling (DEFMACRO WITH-STREAM-INPUT-BUFFER ...)
; compiling (DEFGENERIC STREAM-FILL-BUFFER ...)
; compiling (DEFMETHOD STREAM-FILL-BUFFER ...)
; compiling (DEFMETHOD STREAM-READ-BYTE ...)
; compiling (DEFMETHOD STREAM-READ-CHAR ...)
; compiling (DEFMETHOD STREAM-READ-CHAR-NO-HANG ...)
; compiling (DEFMETHOD STREAM-UNREAD-CHAR ...)
; compiling (DEFMETHOD STREAM-PEEK-CHAR ...)
; compiling (DEFMETHOD STREAM-READ-LINE ...)
; compiling (DEFMETHOD STREAM-READ-SEQUENCE ...)
; compiling (DEFMETHOD STREAM-ELEMENT-TYPE ...)
; compiling (DECLAIM (INLINE %WRITER-FUNCTION-FOR-SEQUENCE))
; compiling (DEFUN %WRITER-FUNCTION-FOR-SEQUENCE ...)
; compiling (DEFUN WRITE-ELEMENTS ...)
; compiling (DEFGENERIC STREAM-WRITE-BUFFER ...)
; compiling (DEFMETHOD STREAM-WRITE-BUFFER ...)
; compiling (DEFGENERIC STREAM-FLUSH-BUFFER ...)
; compiling (DEFMETHOD STREAM-FLUSH-BUFFER ...)
; compiling (DEFMETHOD STREAM-WRITE-BYTE ...)
; compiling (DEFMETHOD STREAM-WRITE-CHAR ...)
; compiling (DEFMETHOD STREAM-WRITE-STRING ...)
; compiling (DEFMETHOD STREAM-WRITE-SEQUENCE ...)
; compiling (DEFMETHOD STREAM-ELEMENT-TYPE ...)
; compiling (DEFMETHOD STREAM-LINE-COLUMN ...)
; compiling (DEFMETHOD STREAM-FINISH-OUTPUT ...)
; compiling (DEFMETHOD STREAM-FORCE-OUTPUT ...)
; compiling (DEFMETHOD STREAM-CLEAR-OUTPUT ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/lw-buffering.fasl written
; compilation finished in 0:00:03
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/acl-excl-common.lisp" (written 07 FEB 2005 07:41:22 AM):
; compiling (IN-PACKAGE :ACL-COMPAT.EXCL)
; compiling (DEFVAR IF*-KEYWORD-LIST ...)
; compiling (DEFMACRO IF* ...)
; compiling (DEFVAR *INITIAL-TERMINAL-IO* ...)
; compiling (DEFVAR *CL-DEFAULT-SPECIAL-BINDINGS* ...)
; compiling (DEFUN FILESYS-SIZE ...)
; compiling (DEFUN FILESYS-WRITE-DATE ...)
; compiling (DEFUN FROB-REGEXP ...)
; compiling (DEFUN MATCH-REGEXP ...)
; compiling (DEFUN COMPILE-REGEXP ...)
; compiling (DEFVAR *CURRENT-CASE-MODE* ...)
; compiling (DEFUN INTERN* ...)
; compiling (DEFMACRO ERRORSET ...)
; compiling (DEFMACRO FAST ...)
; compiling (DEFUN WRITE-VECTOR ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/acl-excl-common.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/sbcl/acl-excl.lisp" (written 05 SEP 2004 08:27:27 AM):
; compiling (IN-PACKAGE :ACL-COMPAT.EXCL)
; compiling (DEFUN STREAM-INPUT-FN ...)
; compiling (DEFUN FILESYS-TYPE ...)
; compiling (DEFMACRO ATOMICALLY ...)
; compiling (DEFUN UNIX-SIGNAL ...)
; compiling (DEFUN FILESYS-INODE ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/sbcl/acl-excl.lisp
; in: DEFUN FILESYS-INODE
;     (MULTIPLE-VALUE-BIND
;       (ACL-COMPAT.EXCL::FOUND ACL-COMPAT.EXCL::IGN ACL-COMPAT.EXCL::INODE)
;       (SB-UNIX:UNIX-LSTAT ACL-COMPAT.EXCL::PATH)
;     (IF ACL-COMPAT.EXCL::FOUND
;         ACL-COMPAT.EXCL::INODE
;         (ERROR "path ~s does not exist" ACL-COMPAT.EXCL::PATH)))
; --> MULTIPLE-VALUE-CALL 
; ==>
;   #'(LAMBDA
;         (&OPTIONAL (ACL-COMPAT.EXCL::FOUND) (ACL-COMPAT.EXCL::IGN)
;          (ACL-COMPAT.EXCL::INODE)
;          &REST #:G18)
;       (DECLARE (IGNORE #:G18))
;       (IF ACL-COMPAT.EXCL::FOUND
;           ACL-COMPAT.EXCL::INODE
;           (ERROR "path ~s does not exist" ACL-COMPAT.EXCL::PATH)))
; 
; caught STYLE-WARNING:
;   The variable IGN is defined but never used.

; compiling (DEFUN CL-INTERNAL-REAL-TIME ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/sbcl/acl-excl.fasl written
; compilation finished in 0:00:00
WARNING:
   COMPILE-FILE warned while performing #<COMPILE-OP NIL {40007E91}> on
   #<UNPORTABLE-CL-SOURCE-FILE "acl-excl" {40147551}>.
STYLE-WARNING: redefining MAKE-BUFFER-STATE in DEFUN
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/chunked-stream-mixin.lisp" (written 14 FEB 2004 06:34:28 AM):
; compiling (IN-PACKAGE :DE.DATAHEAVEN.CHUNKED-STREAM-MIXIN)
; compiling (DEFUN BUFFER-REF ...)
; compiling (DEFUN (SETF BUFFER-REF) ...)
; compiling (DEFCLASS CHUNKED-STREAM-MIXIN ...)
; compiling (DEFGENERIC INPUT-CHUNKING-P ...)
; compiling (DEFMETHOD INPUT-CHUNKING-P ...)
; compiling (DEFGENERIC (SETF INPUT-CHUNKING-P) ...)
; compiling (DEFMETHOD (SETF INPUT-CHUNKING-P) ...)
; compiling (DEFINE-CONDITION ACL-COMPAT.EXCL::SOCKET-CHUNKING-END-OF-FILE ...)
; compiling (DEFGENERIC INITIALIZE-INPUT-CHUNKING ...)
; compiling (DEFMETHOD INITIALIZE-INPUT-CHUNKING ...)
; compiling (DEFMETHOD GRAY-STREAM:STREAM-FILL-BUFFER ...)
; compiling (DEFCONSTANT +CHUNK-HEADER-BUFFER-OFFSET+ ...)
; compiling (DEFGENERIC INITIALIZE-OUTPUT-CHUNKING ...)
; compiling (DEFMETHOD INITIALIZE-OUTPUT-CHUNKING ...)
; compiling (DEFMETHOD GRAY-STREAM:STREAM-FLUSH-BUFFER ...)
; compiling (DEFMETHOD CLOSE ...)
; compiling (DEFGENERIC DISABLE-OUTPUT-CHUNKING ...)
; compiling (DEFMETHOD DISABLE-OUTPUT-CHUNKING ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/chunked-stream-mixin.fasl written
; compilation finished in 0:00:02
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/sbcl/acl-mp.lisp" (written 01 NOV 2004 05:58:10 AM):
; compiling (IN-PACKAGE :ACL-COMPAT.MP)
; compiling (DEFSTRUCT (PROCESS # ...) ...)
; compiling (DEFUN MAKE-PROCESS ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/sbcl/acl-mp.lisp
; in: DEFUN MAKE-PROCESS
;     (DEFUN ACL-COMPAT.MP:MAKE-PROCESS
;          (&KEY (ACL-COMPAT.MP::NAME "Anonymous") ACL-COMPAT.MP::RESET-ACTION
;           ACL-COMPAT.MP::RUN-REASONS ACL-COMPAT.MP::ARREST-REASONS
;           (ACL-COMPAT.MP::PRIORITY 0) ACL-COMPAT.MP::QUANTUM
;           ACL-COMPAT.MP::RESUME-HOOK ACL-COMPAT.MP::SUSPEND-HOOK
;           ACL-COMPAT.MP::INITIAL-BINDINGS ACL-COMPAT.MP::RUN-IMMEDIATELY)
;     (DECLARE
;      (IGNORE ACL-COMPAT.MP::RESET-ACTION
;              ACL-COMPAT.MP::ARREST-REASONS
;              ACL-COMPAT.MP::PRIORITY
;              ACL-COMPAT.MP::QUANTUM
;              ACL-COMPAT.MP::RESUME-HOOK
;              ACL-COMPAT.MP::SUSPEND-HOOK
;              ACL-COMPAT.MP::RUN-IMMEDIATELY))
;     (ACL-COMPAT.MP::%MAKE-PROCESS :NAME
;                                   "the only process"
;                                   :RUN-REASONS
;                                   ACL-COMPAT.MP::RUN-REASONS
;                                   :INITIAL-BINDINGS
;                                   ACL-COMPAT.MP::INITIAL-BINDINGS))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA ACL-COMPAT.MP:MAKE-PROCESS
;                          (&KEY (ACL-COMPAT.MP::NAME "Anonymous")
;                                ACL-COMPAT.MP::RESET-ACTION
;                                ACL-COMPAT.MP::RUN-REASONS
;                                ACL-COMPAT.MP::ARREST-REASONS
;                                (ACL-COMPAT.MP::PRIORITY 0)
;                                ACL-COMPAT.MP::QUANTUM
;                                ACL-COMPAT.MP::RESUME-HOOK
;                                ACL-COMPAT.MP::SUSPEND-HOOK
;                                ACL-COMPAT.MP::INITIAL-BINDINGS
;                                ACL-COMPAT.MP::RUN-IMMEDIATELY)
;                          (DECLARE
;                           (IGNORE ACL-COMPAT.MP::RESET-ACTION
;                                   ACL-COMPAT.MP::ARREST-REASONS
;                                   ACL-COMPAT.MP::PRIORITY
;                                   ACL-COMPAT.MP::QUANTUM
;                                   ACL-COMPAT.MP::RESUME-HOOK
;                                   ACL-COMPAT.MP::SUSPEND-HOOK
;                                   ACL-COMPAT.MP::RUN-IMMEDIATELY))
;                          (BLOCK ACL-COMPAT.MP:MAKE-PROCESS
;                            (ACL-COMPAT.MP::%MAKE-PROCESS :NAME
;                                                          "the only process"
;                                                          :RUN-REASONS
;                                                          ACL-COMPAT.MP::RUN-REASONS
;                                                          :INITIAL-BINDINGS
;                                                          ACL-COMPAT.MP::INITIAL-BINDINGS)))
; 
; caught STYLE-WARNING:
;   The variable NAME is defined but never used.

; compiling (DEFPARAMETER *CURRENT-PROCESS* ...)
; compiling (DEFPARAMETER *ALL-PROCESSES* ...)
; compiling (DEFMACRO DEFUN/SB-THREAD ...); in: LAMBDA NIL
;     (LET* ((ACL-COMPAT.MP::NAME (CAR (CDR #:WHOLE119)))
;          (ACL-COMPAT.MP::ARGS (CAR (CDR #)))
;          (ACL-COMPAT.MP::BODY (CDR (CDR #))))
;     (BLOCK ACL-COMPAT.MP::DEFUN/SB-THREAD
;       `(DEFUN ,ACL-COMPAT.MP::NAME ,ACL-COMPAT.MP::ARGS
;          (DECLARE (IGNORE ,@#))
;          (ERROR
;           ,"~A: Calling a multiprocessing function on a single-threaded sbcl build"
;           ',ACL-COMPAT.MP::NAME))))
; 
; caught STYLE-WARNING:
;   The variable BODY is defined but never used.

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/sbcl/acl-mp.lisp
; in: DEFMACRO DEFUN/SB-THREAD
;     (DEFMACRO ACL-COMPAT.MP::DEFUN/SB-THREAD
;             (ACL-COMPAT.MP::NAME ACL-COMPAT.MP::ARGS &BODY ACL-COMPAT.MP::BODY)
;     `(DEFUN ,ACL-COMPAT.MP::NAME ,ACL-COMPAT.MP::ARGS
;        (DECLARE (IGNORE ,@(REMOVE-IF # #)))
;        (ERROR
;         ,"~A: Calling a multiprocessing function on a single-threaded sbcl build"
;         ',ACL-COMPAT.MP::NAME)))
; --> EVAL-WHEN SB-C::%DEFMACRO SB-C::%DEFMACRO FUNCTION LET* 
; ==>
;   (LET* ((ACL-COMPAT.MP::NAME (CAR (CDR #:WHOLE119)))
;          (ACL-COMPAT.MP::ARGS (CAR (CDR #)))
;          (ACL-COMPAT.MP::BODY (CDR (CDR #))))
;     (BLOCK ACL-COMPAT.MP::DEFUN/SB-THREAD
;       `(DEFUN ,ACL-COMPAT.MP::NAME ,ACL-COMPAT.MP::ARGS
;          (DECLARE (IGNORE ,@#))
;          (ERROR
;           ,"~A: Calling a multiprocessing function on a single-threaded sbcl build"
;           ',ACL-COMPAT.MP::NAME))))
; 
; caught STYLE-WARNING:
;   The variable BODY is defined but never used.

; compiling (DEFUN/SB-THREAD PROCESS-INTERRUPT ...)
; compiling (DEFUN/SB-THREAD PROCESS-WAIT-FUNCTION ...)
; compiling (DEFUN/SB-THREAD PROCESS-WAIT ...)
; compiling (DEFUN/SB-THREAD PROCESS-ALLOW-SCHEDULE ...)
; compiling (DEFUN/SB-THREAD PROCESS-REVOKE-RUN-REASON ...)
; compiling (DEFUN/SB-THREAD PROCESS-ADD-RUN-REASON ...)
; compiling (DEFUN/SB-THREAD PROCESS-RUN-FUNCTION ...)
; compiling (DEFUN/SB-THREAD PROCESS-PRESET ...)
; compiling (DEFUN/SB-THREAD PROCESS-KILL ...)
; compiling (DEFUN/SB-THREAD MAKE-PROCESS-LOCK ...)
; compiling (DEFUN/SB-THREAD PROCESS-LOCK ...)
; compiling (DEFUN/SB-THREAD PROCESS-UNLOCK ...)
; compiling (DEFMACRO WITH-PROCESS-LOCK ...)
; compiling (DEFMACRO WITHOUT-SCHEDULING ...)
; compiling (DEFMACRO WITH-TIMEOUT ...)
; compiling (DEFUN/SB-THREAD RESTART-PROCESS ...)
; compiling (DEFUN CURRENT-PROCESS ...)
; compiling (DEFUN ALL-PROCESSES ...)
; compiling (DEFUN/SB-THREAD PROCESS-WAIT-WITH-TIMEOUT ...)compilation aborted because of fatal error:
                                                             READ failure in COMPILE-FILE:
                                                               READER-ERROR at 9422 (line 246, column 39) on #<SB-SYS:FD-STREAM for "file /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/sbcl/acl-mp.lisp" {40008AE1}>:
Symbol "CURRENT-THREAD-ID" not found in the SB-THREAD package.

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/acl-compat/sbcl/acl-mp.fasl written
; compilation finished in 0:00:01
WARNING:
   COMPILE-FILE warned while performing #<COMPILE-OP NIL {40007F59}> on
   #<UNPORTABLE-CL-SOURCE-FILE "acl-mp" {40007F69}>.
; 
; compilation unit aborted
;   caught 2 fatal ERROR conditions
;   caught 4 STYLE-WARNING conditions
erred while invoking #<COMPILE-OP NIL {40007F59}> on
#<UNPORTABLE-CL-SOURCE-FILE "acl-mp" {40007F69}>
Back