x11-wm:stumpwm-22.05_p20220818:20221226-043653.log

x11-wm:stumpwm-22.05_p20220818:20221226-043653.log (text/plain), 426.20 KB, created by Jonathan Lovelace on 2022-12-26 05:02:12 UTC

 * Package:    x11-wm/stumpwm-22.05_p20220818:0
 * Repository: gentoo
 * USE:        abi_x86_64 amd64 elibc_glibc kernel_linux userland_GNU
 * FEATURES:   distcc fakeroot network-sandbox preserve-libs sandbox test userpriv usersandbox
 * Running eautoreconf in '/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2' ...
 * Running 'aclocal --system-acdir=/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/temp/aclocal' ...
 [ ok ]
 * Running 'autoconf --force' ...
 [ ok ]
 [m[1m[32m*[m Running elibtoolize in: stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/
configure: loading site script /usr/share/config.site
checking for sbcl... /usr/bin/sbcl
configure: Using sbcl at /usr/bin/sbcl
checking for makeinfo... yes
configure: creating ./config.status
config.status: creating Makefile
configure: creating ./config.status
config.status: creating Makefile
config.status: creating make-image.lisp
configure: creating ./config.status
config.status: creating Makefile
config.status: creating make-image.lisp
config.status: creating load-stumpwm.lisp
/usr/bin/sbcl --non-interactive --eval "(setf sb-impl::*default-external-format* :UTF-8)" --load ./make-image.lisp
This is SBCL 2.2.9, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.

SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses.  See the CREDITS and COPYING files in the
distribution for more information.
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/package.lisp" (written 14 MAY 2022 03:42:19 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-1/package-tmpGHU3ALSV.fasl
; compilation finished in 0:00:00.020
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/definitions.lisp" (written 14 MAY 2022 03:42:21 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-1/definitions-tmpAAURSO1.fasl
; compilation finished in 0:00:00.028
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/binding.lisp" (written 14 MAY 2022 03:42:18 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-1/binding-tmp5GEXGEG5.fasl
; compilation finished in 0:00:00.048
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/strings.lisp" (written 14 MAY 2022 03:42:20 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-1/strings-tmpAR3FSGEY.fasl
; compilation finished in 0:00:00.002
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/conditions.lisp" (written 14 MAY 2022 03:42:20 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-1/conditions-tmpJAIDFZTC.fasl
; compilation finished in 0:00:00.025
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/symbols.lisp" (written 14 MAY 2022 03:42:19 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-1/symbols-tmp8V3J6PE9.fasl
; compilation finished in 0:00:00.015
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/macros.lisp" (written 14 MAY 2022 03:42:20 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-1/macros-tmp9V47YWQF.fasl
; compilation finished in 0:00:00.083
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/functions.lisp" (written 14 MAY 2022 03:42:20 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-1/functions-tmp9BN22RMA.fasl
; compilation finished in 0:00:00.062
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/lists.lisp" (written 14 MAY 2022 03:42:21 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-1/lists-tmp1CXFJSK9.fasl
; compilation finished in 0:00:00.096
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/types.lisp" (written 14 MAY 2022 03:42:20 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-1/types-tmpX4BRKI0R.fasl
; compilation finished in 0:00:00.061
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/io.lisp" (written 14 MAY 2022 03:42:19 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-1/io-tmpQ371UGST.fasl
; compilation finished in 0:00:00.266
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/hash-tables.lisp" (written 14 MAY 2022 03:42:19 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-1/hash-tables-tmp2OWI3Q7U.fasl
; compilation finished in 0:00:00.133
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/control-flow.lisp" (written 14 MAY 2022 03:42:19 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-1/control-flow-tmp9KKTJMYV.fasl
; compilation finished in 0:00:00.045
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/arrays.lisp" (written 14 MAY 2022 03:42:19 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-1/arrays-tmpJU0JWO19.fasl
; compilation finished in 0:00:00.024
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/sequences.lisp" (written 14 MAY 2022 03:42:21 PM):

; file: /usr/share/common-lisp/source/alexandria/alexandria-1/sequences.lisp
; in: DEFUN LENGTH=
;     (LENGTH FIRST)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFUN MAP-DERANGEMENTS
;     (MAKE-ARRAY ALEXANDRIA::SIZE :ELEMENT-TYPE 'BIT :INITIAL-ELEMENT 0)
; 
; note: could not stack allocate:
;        (MAKE-ARRAY SIZE :ELEMENT-TYPE 'BIT :INITIAL-ELEMENT 0)


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-1/sequences-tmpZX2WN8N4.fasl
; compilation finished in 0:00:00.150
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/numbers.lisp" (written 14 MAY 2022 03:42:20 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-1/numbers-tmpOU81XRV0.fasl
; compilation finished in 0:00:00.108
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/features.lisp" (written 14 MAY 2022 03:42:19 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-1/features-tmpY2ML9CFA.fasl
; compilation finished in 0:00:00.010
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-2/package.lisp" (written 14 MAY 2022 03:42:21 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-2/package-tmpX2JYJDQE.fasl
; compilation finished in 0:00:00.041
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-2/arrays.lisp" (written 14 MAY 2022 03:42:21 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-2/arrays-tmpOPCILR65.fasl
; compilation finished in 0:00:00.030
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-2/control-flow.lisp" (written 14 MAY 2022 03:42:21 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-2/control-flow-tmpRV9F8A9A.fasl
; compilation finished in 0:00:00.011
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-2/sequences.lisp" (written 14 MAY 2022 03:42:22 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-2/sequences-tmpK2ZAJT4I.fasl
; compilation finished in 0:00:00.014
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-2/lists.lisp" (written 14 MAY 2022 03:42:22 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/alexandria/alexandria-2/lists-tmpUX5S4ADN.fasl
; compilation finished in 0:00:00.012
; compiling file "/usr/share/common-lisp/source/cl-ppcre/packages.lisp" (written 07 APR 2020 10:50:14 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/cl-ppcre/packages-tmp10401X32.fasl
; compilation finished in 0:00:00.015
; compiling file "/usr/share/common-lisp/source/cl-ppcre/specials.lisp" (written 07 APR 2020 10:50:15 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/cl-ppcre/specials-tmpZ7CBRM0G.fasl
; compilation finished in 0:00:00.031
; compiling file "/usr/share/common-lisp/source/cl-ppcre/util.lisp" (written 07 APR 2020 10:50:15 PM):

; file: /usr/share/common-lisp/source/cl-ppcre/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 * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a STRING, not a SIMPLE-BASE-STRING.

; in: DEFUN COMPLEMENT*
;     (FUNCALL CL-PPCRE::TEST-FUNCTION CHAR)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/cl-ppcre/util-tmp9OZEQ0G2.fasl
; compilation finished in 0:00:00.054
; compiling file "/usr/share/common-lisp/source/cl-ppcre/errors.lisp" (written 07 APR 2020 10:50:14 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/cl-ppcre/errors-tmpB2JTL1W9.fasl
; compilation finished in 0:00:00.026
; compiling file "/usr/share/common-lisp/source/cl-ppcre/charset.lisp" (written 07 APR 2020 10:50:13 PM):

; file: /usr/share/common-lisp/source/cl-ppcre/charset.lisp
; in: DEFUN MIX
;     (+ CL-PPCRE::CODE CL-PPCRE::HASH)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (SIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

; in: DEFUN COMPUTE-INDEX
;     (LENGTH VECTOR)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (MOD CL-PPCRE::HASH (1- (LENGTH VECTOR)))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (1+ (MOD CL-PPCRE::HASH (1- (LENGTH VECTOR))))
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL (-4611686018427387899)
;                                         (4611686018427387899))), not a FLOAT.
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL (-4611686018427387899)
;                                         (4611686018427387899))), not a RATIONAL.

;     (MOD CL-PPCRE::HASH (1- (LENGTH VECTOR)))
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL (-4611686018427387899)
;                                         (4611686018427387899))), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL (-4611686018427387899)
;                                         (4611686018427387899))), not a FLOAT.
; 
; 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 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.
; 
; 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 arithmetic (cost 2) because:
;       The first argument is a (OR FLOAT
;                                   (RATIONAL (-4611686018427387899)
;                                             (4611686018427387899))), not a FIXNUM.
;       The result is a (VALUES
;                        (OR FLOAT
;                            (RATIONAL (-4611686018427387899)
;                                      (4611686018427387899)))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR FLOAT
;                                   (RATIONAL (-4611686018427387899)
;                                             (4611686018427387899))), not a (SIGNED-BYTE
;                                                                             64).
;       The result is a (VALUES
;                        (OR FLOAT
;                            (RATIONAL (-4611686018427387899)
;                                      (4611686018427387899)))
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (1+ (MOD CL-PPCRE::HASH (1- (LENGTH VECTOR))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (OR FLOAT
;                                   (RATIONAL (-4611686018427387899)
;                                             (4611686018427387899))), not a FIXNUM.
;       The result is a (VALUES
;                        (OR FLOAT
;                            (RATIONAL (-4611686018427387898)
;                                      (4611686018427387900)))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR FLOAT
;                                   (RATIONAL (-4611686018427387899)
;                                             (4611686018427387899))), not a FIXNUM.
;       The result is a (VALUES
;                        (OR FLOAT
;                            (RATIONAL (-4611686018427387898)
;                                      (4611686018427387900)))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

; in: DEFUN %ADD-TO-CHARSET/EXPAND
;     (* 2 CL-PPCRE::NEW-SIZE)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   associate */(* /) of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (>= CL-PPCRE::NEW-SIZE 371370)
; 
; 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 FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL * 371370) (SINGLE-FLOAT * 371370.0)
;                               (DOUBLE-FLOAT * 371370.0d0)), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (* 2 CL-PPCRE::NEW-SIZE)
; 
; note: forced to do GENERIC-* (cost 30)
;       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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (>= CL-PPCRE::NEW-SIZE 371370)
; 
; 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.

;     (* 2 (LENGTH CL-PPCRE::OLD-VECTOR))
; 
; note: doing unsigned word to integer coercion (cost 20), for:
;       the first result of inline ASH

; in: DEFUN MAP-CHARSET
;     (DECF CL-PPCRE::N)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER * 4611686018427387903), not a FIXNUM.
;       The result is a (VALUES (INTEGER * 4611686018427387902) &OPTIONAL), not a (VALUES
;                                                                                  FIXNUM
;                                                                                  &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER * 4611686018427387903), not a FIXNUM.
;       The result is a (VALUES (INTEGER * 4611686018427387902) &OPTIONAL), not a (VALUES
;                                                                                  FIXNUM
;                                                                                  &OPTIONAL).
;       etc.

; in: DEFUN CREATE-CHARSET-FROM-TEST-FUNCTION
;     (FUNCALL CL-PPCRE::TEST-FUNCTION CHAR)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function

;     (LOOP CL-PPCRE::WITH CL-PPCRE::CHARSET = (CL-PPCRE::MAKE-CHARSET)
;           CL-PPCRE::FOR CL-PPCRE::CODE CL-PPCRE::FROM CL-PPCRE::START CL-PPCRE::BELOW
;           CL-PPCRE::END
;           CL-PPCRE::FOR ...)
; --> LET LET LET TAGBODY WHEN IF >= 
; ==>
;   1
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; 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.
; 
; note: forced to do GENERIC-= (cost 10)
;       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.
;       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.


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/cl-ppcre/charset-tmpP3BI68WQ.fasl
; compilation finished in 0:00:00.056
; compiling file "/usr/share/common-lisp/source/cl-ppcre/charmap.lisp" (written 07 APR 2020 10:50:13 PM):

; file: /usr/share/common-lisp/source/cl-ppcre/charmap.lisp
; in: DEFUN MAKE-CHARMAP
;     (FUNCALL CL-PPCRE::TEST-FUNCTION CHAR)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function

; in: DEFUN CREATE-CHARMAP-FROM-TEST-FUNCTION
;     (1- CL-PPCRE::END)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (LOOP CL-PPCRE::FOR CL-PPCRE::CODE CL-PPCRE::FROM (1-
;                                                        CL-PPCRE::END) CL-PPCRE::DOWNTO CL-PPCRE::START
;           CL-PPCRE::FOR CHAR = (CODE-CHAR CL-PPCRE::CODE)
;           CL-PPCRE::UNTIL ...)
; --> LET LET TAGBODY WHEN IF 
; ==>
;   (< CL-PPCRE::CODE #:LOOP-LIMIT-18)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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.

;     (FUNCALL CL-PPCRE::TEST-FUNCTION CHAR)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function

;     (LOOP CL-PPCRE::FOR CL-PPCRE::CODE CL-PPCRE::FROM CL-PPCRE::START CL-PPCRE::BELOW
;           CL-PPCRE::END
;           CL-PPCRE::FOR CHAR = (CODE-CHAR CL-PPCRE::CODE)
;           CL-PPCRE::UNTIL ...)
; --> LET LET TAGBODY WHEN IF >= 
; ==>
;   1
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; 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.
; 
; note: forced to do GENERIC-= (cost 10)
;       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.
;       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.

;     (1- CL-PPCRE::END)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (LOOP CL-PPCRE::FOR CL-PPCRE::CODE CL-PPCRE::FROM (1-
;                                                        CL-PPCRE::END) CL-PPCRE::DOWNTO CL-PPCRE::START
;           CL-PPCRE::FOR CHAR = (CODE-CHAR CL-PPCRE::CODE)
;           CL-PPCRE::UNTIL ...)
; --> LET LET TAGBODY WHEN IF 
; ==>
;   (< CL-PPCRE::CODE #:LOOP-LIMIT-18)
; 
; 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.


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/cl-ppcre/charmap-tmpQDARA81Z.fasl
; compilation finished in 0:00:00.066
; compiling file "/usr/share/common-lisp/source/cl-ppcre/chartest.lisp" (written 07 APR 2020 10:50:13 PM):

; file: /usr/share/common-lisp/source/cl-ppcre/chartest.lisp
; in: DEFUN CREATE-HASH-TABLE-FROM-TEST-FUNCTION
;     (FUNCALL CL-PPCRE::TEST-FUNCTION CHAR)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function

;     (LOOP CL-PPCRE::WITH HASH-TABLE = (MAKE-HASH-TABLE)
;           CL-PPCRE::FOR CL-PPCRE::CODE CL-PPCRE::FROM CL-PPCRE::START CL-PPCRE::BELOW
;           CL-PPCRE::END
;           CL-PPCRE::FOR ...)
; --> LET LET LET TAGBODY WHEN IF >= 
; ==>
;   1
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; 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.
; 
; note: forced to do GENERIC-= (cost 10)
;       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.
;       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.

; in: DEFUN CREATE-OPTIMIZED-TEST-FUNCTION
;     (- CL-PPCRE::END CL-PPCRE::START)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

;     (CEILING (- CL-PPCRE::END CL-PPCRE::START) 2)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert integer division to multiplication
; due to type uncertainty:
;   The first argument is a REAL, not a (SIGNED-BYTE 64).
; 
; note: unable to
;   convert integer division to multiplication
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 64).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT (RATIONAL (-2) (2))), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (- CL-PPCRE::END CL-PPCRE::START)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

;     (CEILING (- CL-PPCRE::END CL-PPCRE::START) 2)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert integer division to multiplication
; due to type uncertainty:
;   The first argument is a REAL, not a (SIGNED-BYTE 64).
; 
; note: unable to
;   convert integer division to multiplication
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 64).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT (RATIONAL (-2) (2))), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (- CL-PPCRE::END CL-PPCRE::START)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       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 REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                              &OPTIONAL).
;       etc.

;     (CEILING (- CL-PPCRE::END CL-PPCRE::START) 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.
; 
; 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
;                                                                 &OPTIONAL).
;       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
;                                                                 &OPTIONAL).
;       etc.

;     (- CL-PPCRE::END CL-PPCRE::START)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       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 REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                              &OPTIONAL).
;       etc.

;     (CEILING (- CL-PPCRE::END CL-PPCRE::START) 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.
; 
; 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
;                                                                 &OPTIONAL).
;       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
;                                                                 &OPTIONAL).
;       etc.


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/cl-ppcre/chartest-tmpYEMMM7SE.fasl
; compilation finished in 0:00:00.054
; compiling file "/usr/share/common-lisp/source/cl-ppcre/lexer.lisp" (written 07 APR 2020 10:50:14 PM):

; file: /usr/share/common-lisp/source/cl-ppcre/lexer.lisp
; in: DEFUN NEXT-CHAR
;     (- (CL-PPCRE::LEXER-POS CL-PPCRE::LEXER) 2)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first result of inline (signed-byte 64) arithmetic

; 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.


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/cl-ppcre/lexer-tmp73HU0RPK.fasl
; compilation finished in 0:00:00.130
; compiling file "/usr/share/common-lisp/source/cl-ppcre/parser.lisp" (written 07 APR 2020 10:50:14 PM):

; file: /usr/share/common-lisp/source/cl-ppcre/parser.lisp
; in: DEFUN GROUP
;     (+ CL-PPCRE::OPEN-PAREN-POS 2)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first result of inline (signed-byte 64) arithmetic


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/cl-ppcre/parser-tmpIO5N7K88.fasl
; compilation finished in 0:00:00.032
; compiling file "/usr/share/common-lisp/source/cl-ppcre/regex-class.lisp" (written 07 APR 2020 10:50:15 PM):

; file: /usr/share/common-lisp/source/cl-ppcre/regex-class.lisp
; in: DEFMETHOD INITIALIZE-INSTANCE :AFTER (STR)
;     (COERCE CL-PPCRE::STR-SLOT 'SIMPLE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST
;                               (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
;                                    (NOT SIMPLE-BASE-STRING) VECTOR)
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
;                                     (NOT SIMPLE-BASE-STRING) VECTOR)
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
;                                                                     * (*)).

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


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/cl-ppcre/regex-class-tmpCM21U60Z.fasl
; compilation finished in 0:00:00.034
; compiling file "/usr/share/common-lisp/source/cl-ppcre/regex-class-util.lisp" (written 07 APR 2020 10:50:14 PM):

; file: /usr/share/common-lisp/source/cl-ppcre/regex-class-util.lisp
; in: DEFMETHOD CASE-MODE (STR T)
;     (ZEROP (CL-PPCRE::LEN CL-PPCRE::STR))
; 
; 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
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to open code because: The operands might not be the same type.

; in: DEFMETHOD EVERYTHINGP (SEQ)
;     (LENGTH CL-PPCRE::CLEANED-ELEMENTS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (SIMPLE-ARRAY * (*))
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; in: DEFMETHOD EVERYTHINGP (ALTERNATION)
;     (LENGTH CL-PPCRE::CHOICES)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFMETHOD EVERYTHINGP (REPETITION)
;     (= 1 CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM)
; 
; 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
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a (OR (INTEGER 1 1) (SINGLE-FLOAT 1.0 1.0)
;                               (DOUBLE-FLOAT 1.0d0 1.0d0)
;                               (COMPLEX (INTEGER 1 1))
;                               (COMPLEX (SINGLE-FLOAT 1.0 1.0))
;                               (COMPLEX
;                                (DOUBLE-FLOAT 1.0d0 1.0d0))), not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a (OR (INTEGER 1 1) (SINGLE-FLOAT 1.0 1.0)
;                               (DOUBLE-FLOAT 1.0d0 1.0d0)
;                               (COMPLEX (INTEGER 1 1))
;                               (COMPLEX (SINGLE-FLOAT 1.0 1.0))
;                               (COMPLEX
;                                (DOUBLE-FLOAT 1.0d0 1.0d0))), not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a (OR (INTEGER 1 1) (SINGLE-FLOAT 1.0 1.0)
;                               (DOUBLE-FLOAT 1.0d0 1.0d0)
;                               (COMPLEX (INTEGER 1 1))
;                               (COMPLEX (SINGLE-FLOAT 1.0 1.0))
;                               (COMPLEX
;                                (DOUBLE-FLOAT 1.0d0 1.0d0))), not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a (OR (INTEGER 1 1) (SINGLE-FLOAT 1.0 1.0)
;                               (DOUBLE-FLOAT 1.0d0 1.0d0)
;                               (COMPLEX (INTEGER 1 1))
;                               (COMPLEX (SINGLE-FLOAT 1.0 1.0))
;                               (COMPLEX
;                                (DOUBLE-FLOAT 1.0d0 1.0d0))), not a (COMPLEX
;                                                                     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 (OR (INTEGER 1 1) (SINGLE-FLOAT 1.0 1.0)
;                               (DOUBLE-FLOAT 1.0d0 1.0d0)
;                               (COMPLEX (INTEGER 1 1))
;                               (COMPLEX (SINGLE-FLOAT 1.0 1.0))
;                               (COMPLEX
;                                (DOUBLE-FLOAT 1.0d0 1.0d0))), not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (INTEGER 1 1) (SINGLE-FLOAT 1.0 1.0)
;                               (DOUBLE-FLOAT 1.0d0 1.0d0)
;                               (COMPLEX (INTEGER 1 1))
;                               (COMPLEX (SINGLE-FLOAT 1.0 1.0))
;                               (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))), not a (OR
;                                                                             (COMPLEX
;                                                                              SINGLE-FLOAT)
;                                                                             (COMPLEX
;                                                                              DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR (INTEGER 1 1) (SINGLE-FLOAT 1.0 1.0)
;                                   (DOUBLE-FLOAT 1.0d0 1.0d0)
;                                   (COMPLEX (INTEGER 1 1))
;                                   (COMPLEX (SINGLE-FLOAT 1.0 1.0))
;                                   (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))), not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR (INTEGER 1 1) (SINGLE-FLOAT 1.0 1.0)
;                                   (DOUBLE-FLOAT 1.0d0 1.0d0)
;                                   (COMPLEX (INTEGER 1 1))
;                                   (COMPLEX (SINGLE-FLOAT 1.0 1.0))
;                                   (COMPLEX (DOUBLE-FLOAT 1.0d0 1.0d0))), not a (COMPLEX
;                                                                                 DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       etc.

; in: DEFMETHOD REGEX-LENGTH (SEQ)
;     (LOOP CL-PPCRE::FOR CL-PPCRE::SUB-REGEX CL-PPCRE::IN (CL-PPCRE::ELEMENTS
;                                                           CL-PPCRE::SEQ)
;           CL-PPCRE::FOR CL-PPCRE::LEN = (CL-PPCRE::REGEX-LENGTH
;                                          CL-PPCRE::SUB-REGEX)
;           IF (NOT CL-PPCRE::LEN)
;           DO ...)
; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-5 CL-PPCRE::LEN)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; 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
;                                                                &OPTIONAL).
;       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
;                                                                &OPTIONAL).
;       etc.

; in: DEFMETHOD REGEX-LENGTH (ALTERNATION)
;     (/= CL-PPCRE::LEN CL-PPCRE::OLD-LEN)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX 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
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: forced to do GENERIC-= (cost 10)
;       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 (COMPLEX DOUBLE-FLOAT).
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       etc.

; in: DEFMETHOD REGEX-LENGTH (BRANCH)
;     (EQL CL-PPCRE::THEN-LENGTH
;          (CL-PPCRE::REGEX-LENGTH (CL-PPCRE::ELSE-REGEX CL-PPCRE::BRANCH)))
; 
; note: forced to do IF-EQL (cost 15)
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a (NOT NULL), not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       etc.

; in: DEFMETHOD REGEX-LENGTH (REPETITION)
;     (* CL-PPCRE::MINIMUM CL-PPCRE::LEN)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

;     (EQL CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM)
; 
; note: forced to do IF-EQL (cost 15)
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       etc.

;     (* CL-PPCRE::MINIMUM CL-PPCRE::LEN)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &OPTIONAL).
;       etc.

; in: DEFMETHOD REGEX-MIN-LENGTH (SEQ)
;     (LOOP CL-PPCRE::FOR CL-PPCRE::SUB-REGEX CL-PPCRE::IN (CL-PPCRE::ELEMENTS
;                                                           CL-PPCRE::SEQ)
;           CL-PPCRE::FOR CL-PPCRE::LEN = (CL-PPCRE::REGEX-MIN-LENGTH
;                                          CL-PPCRE::SUB-REGEX)
;           CL-PPCRE::SUM CL-PPCRE::LEN)
; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-5 CL-PPCRE::LEN)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; 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
;                                                                &OPTIONAL).
;       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
;                                                                &OPTIONAL).
;       etc.

; in: DEFMETHOD REGEX-MIN-LENGTH (ALTERNATION)
;     (LOOP CL-PPCRE::FOR CL-PPCRE::SUB-REGEX CL-PPCRE::IN (CL-PPCRE::CHOICES
;                                                           CL-PPCRE::ALTERNATION)
;           CL-PPCRE::FOR CL-PPCRE::LEN = (CL-PPCRE::REGEX-MIN-LENGTH
;                                          CL-PPCRE::SUB-REGEX)
;           CL-PPCRE::MINIMIZE CL-PPCRE::LEN)
; --> LET LET SB-LOOP::WITH-MINIMAX-VALUE LET TAGBODY 
; --> SB-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN IF OR LET IF < IF 
; ==>
;   (< #:LOOP-MAXMIN-TEMP-9 #:LOOP-MAXMIN-8)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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.
; 
; 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.

; in: DEFMETHOD REGEX-MIN-LENGTH (BRANCH)
;     (MIN (CL-PPCRE::REGEX-MIN-LENGTH (CL-PPCRE::THEN-REGEX CL-PPCRE::BRANCH))
;          (CL-PPCRE::REGEX-MIN-LENGTH (CL-PPCRE::ELSE-REGEX CL-PPCRE::BRANCH)))
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; 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.
; 
; note: forced to do GENERIC-= (cost 10)
;       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.
;       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.

; in: DEFMETHOD REGEX-MIN-LENGTH (REPETITION)
;     (* (CL-PPCRE::MINIMUM CL-PPCRE::REPETITION)
;        (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION))
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &OPTIONAL).
;       etc.

; in: DEFMETHOD COMPUTE-OFFSETS (ALTERNATION T)
;     (/= CL-PPCRE::CURR-OFFSET CL-PPCRE::OLD-OFFSET)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX 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
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: forced to do GENERIC-= (cost 10)
;       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 (COMPLEX DOUBLE-FLOAT).
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       etc.

; in: DEFMETHOD COMPUTE-OFFSETS (BRANCH T)
;     (EQL CL-PPCRE::THEN-OFFSET
;          (CL-PPCRE::COMPUTE-OFFSETS (CL-PPCRE::ELSE-REGEX CL-PPCRE::BRANCH)
;           CL-PPCRE::START-POS))
; 
; note: forced to do IF-EQL (cost 15)
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a (NOT NULL), not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       etc.

; in: DEFMETHOD COMPUTE-OFFSETS (REPETITION T)
;     (* CL-PPCRE::MINIMUM CL-PPCRE::LEN)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

;     (+ CL-PPCRE::START-POS (* CL-PPCRE::MINIMUM CL-PPCRE::LEN))
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

;     (* CL-PPCRE::MINIMUM CL-PPCRE::LEN)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &OPTIONAL).
;       etc.

;     (+ CL-PPCRE::START-POS (* CL-PPCRE::MINIMUM CL-PPCRE::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
;                                                                &OPTIONAL).
;       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
;                                                                &OPTIONAL).
;       etc.

; in: DEFMETHOD COMPUTE-OFFSETS (CHAR-CLASS T)
;     (1+ CL-PPCRE::START-POS)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

; in: DEFMETHOD COMPUTE-OFFSETS (EVERYTHING T)
;     (1+ CL-PPCRE::START-POS)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

; in: DEFMETHOD COMPUTE-OFFSETS (STR T)
;     (+ CL-PPCRE::START-POS (CL-PPCRE::LEN CL-PPCRE::STR))
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; 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
;                                                                &OPTIONAL).
;       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
;                                                                &OPTIONAL).
;       etc.

; in: DEFMETHOD COMPUTE-OFFSETS (FILTER T)
;     (+ CL-PPCRE::START-POS CL-PPCRE::LEN)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; 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
;                                                                &OPTIONAL).
;       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
;                                                                &OPTIONAL).
;       etc.


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/cl-ppcre/regex-class-util-tmp9DT7SEFG.fasl
; compilation finished in 0:00:00.284
; compiling file "/usr/share/common-lisp/source/cl-ppcre/convert.lisp" (written 07 APR 2020 10:50:14 PM):

; file: /usr/share/common-lisp/source/cl-ppcre/convert.lisp
; in: DEFUN CONVERT-CHAR-CLASS-TO-TEST-FUNCTION
;     (FUNCALL CL-PPCRE::TEST-FUNCTION (CHAR-DOWNCASE CHAR))
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function

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

;     (FUNCALL CL-PPCRE::TEST-FUNCTION (CHAR-UPCASE CHAR))
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function

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

;     (FUNCALL CL-PPCRE::TEST-FUNCTION (CHAR-DOWNCASE CHAR))
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function

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

;     (FUNCALL CL-PPCRE::TEST-FUNCTION (CHAR-UPCASE CHAR))
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function

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

;     (FUNCALL CL-PPCRE::TEST-FUNCTION CHAR)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function

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

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

;     (FUNCALL CL-PPCRE::TEST-FUNCTION CL-PPCRE::CHAR-DOWN)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function

;     (FUNCALL CL-PPCRE::TEST-FUNCTION CL-PPCRE::CHAR-UP)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function

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

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

;     (FUNCALL CL-PPCRE::TEST-FUNCTION CL-PPCRE::CHAR-DOWN)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function

;     (FUNCALL CL-PPCRE::TEST-FUNCTION CL-PPCRE::CHAR-UP)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function

; in: DEFUN MAYBE-SPLIT-REPETITION
;     (- CL-PPCRE::MAXIMUM CL-PPCRE::MINIMUM)
; 
; note: doing signed word to integer coercion (cost 20)

; in: DEFUN MAYBE-ACCUMULATE
;     (+ (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH) (CL-PPCRE::LEN CL-PPCRE::STR))
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

;     (- (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH) (CL-PPCRE::LEN CL-PPCRE::STR))
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

;     (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)
; --> SETF LET* 
; ==>
;   (REPLACE #:SEQUENCE #:NEW1 :START1 #:START :END1 NIL)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY * (*))
;                                                       &REST T).
; 
; 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-ARRAY CHARACTER (*)).
;   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-BASE-STRING.
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY CHARACTER
;                                                        (*))
;                                                       &REST T).

;     (+ (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH) (CL-PPCRE::LEN CL-PPCRE::STR))
; 
; 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
;                                                                &OPTIONAL).
;       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
;                                                                &OPTIONAL).
;       etc.

;     (- (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH) (CL-PPCRE::LEN CL-PPCRE::STR))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       etc.

; in: DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ((EQL :BRANCH) T)
;     (LENGTH (CL-PPCRE::CHOICES CL-PPCRE::ALTERNATIONS))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ((EQL :GREEDY-REPETITION) T)
;     (ZEROP LENGTH)
; 
; 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
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to open code because: The operands might not be the same type.

; in: DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ((EQL :NAMED-REGISTER) T)
;     (COPY-SEQ (SECOND CL-PPCRE::PARSE-TREE))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; in: DEFMETHOD CONVERT-COMPOUND-PARSE-TREE ((EQL :BACK-REFERENCE) T)
;     (STRING= CL-PPCRE::NAME CL-PPCRE::BACKREF-NAME)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR STRING SYMBOL CHARACTER), not a STRING.
;   The second argument is a (OR STRING (AND (NOT NULL) SYMBOL)
;                                CHARACTER), not a STRING.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR STRING SYMBOL
;                               CHARACTER), not a SIMPLE-BASE-STRING.
;   The second argument is a (OR STRING (AND (NOT NULL) SYMBOL)
;                                CHARACTER), not a SIMPLE-BASE-STRING.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR STRING SYMBOL CHARACTER), not a (SIMPLE-ARRAY
;                                                                CHARACTER (*)).
;   The second argument is a (OR STRING (AND (NOT NULL) SYMBOL)
;                                CHARACTER), not a (SIMPLE-ARRAY CHARACTER (*)).

;     (- CL-PPCRE::REG-NUM CL-PPCRE::REG-INDEX)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

;     (1- CL-PPCRE::BACKREF-NUMBER)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

;     (COPY-SEQ CL-PPCRE::BACKREF-NAME)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (- CL-PPCRE::REG-NUM CL-PPCRE::REG-INDEX)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &OPTIONAL).
;       etc.

;     (LOOP CL-PPCRE::FOR CL-PPCRE::NAME CL-PPCRE::IN CL-PPCRE::REG-NAMES
;           CL-PPCRE::FOR CL-PPCRE::REG-INDEX CL-PPCRE::FROM 0
;           WHEN (STRING= CL-PPCRE::NAME CL-PPCRE::BACKREF-NAME)
;           CL-PPCRE::COLLECT ...)
; --> LET LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* TAGBODY 
; --> SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   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
;                                                                     &OPTIONAL).
;       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
;                                                                     &OPTIONAL).
;       etc.

;     (1- CL-PPCRE::BACKREF-NUMBER)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

; in: DEFUN CONVERT
;     (COERCE (SLOT-VALUE CL-PPCRE::STARTS-WITH 'CL-PPCRE::STR) 'SIMPLE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST
;                               (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
;                                    (NOT SIMPLE-BASE-STRING) VECTOR)
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
;                                     (NOT SIMPLE-BASE-STRING) VECTOR)
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
;                                                                     * (*)).


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/cl-ppcre/convert-tmp8065ESJT.fasl
; compilation finished in 0:00:00.185
; compiling file "/usr/share/common-lisp/source/cl-ppcre/optimize.lisp" (written 07 APR 2020 10:50:14 PM):

; file: /usr/share/common-lisp/source/cl-ppcre/optimize.lisp
; in: DEFMETHOD GATHER-STRINGS (SEQ)
;     (MAKE-ARRAY CL-PPCRE::COLLECTOR-LENGTH :INITIAL-CONTENTS CL-PPCRE::COLLECTOR
;                 :ELEMENT-TYPE 'CHARACTER :FILL-POINTER T :ADJUSTABLE T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (SIMPLE-ARRAY * (*)), not a SIMPLE-BASE-STRING.

;     (INCF CL-PPCRE::COLLECTOR-LENGTH (CL-PPCRE::LEN CL-PPCRE::ELEMENT))
; --> THE 
; ==>
;   (+ (CL-PPCRE::LEN CL-PPCRE::ELEMENT) CL-PPCRE::COLLECTOR-LENGTH)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       etc.

; in: DEFMETHOD START-ANCHORED-P (REPETITION)
;     (PLUSP (CL-PPCRE::MINIMUM CL-PPCRE::REPETITION))
; 
; 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.

; in: DEFMETHOD START-ANCHORED-P (REGEX)
;     (ZEROP (CL-PPCRE::LEN CL-PPCRE::REGEX))
; 
; 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
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to open code because: The operands might not be the same type.

; in: DEFMETHOD END-STRING-AUX (SEQ)
;     (ZEROP (CL-PPCRE::LEN CL-PPCRE::ELEMENT-END))
; 
; 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
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to open code because: The operands might not be the same type.

;     (MAKE-ARRAY CL-PPCRE::CONCATENATED-LENGTH :INITIAL-CONTENTS
;                 (REVERSE (CL-PPCRE::STR CL-PPCRE::CONCATENATED-START))
;                 :ELEMENT-TYPE 'CHARACTER :FILL-POINTER T :ADJUSTABLE T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (SIMPLE-ARRAY * (*))
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST (SIMPLE-ARRAY * (*))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
;                                                                     * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST (SIMPLE-ARRAY * (*))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a SIMPLE-BASE-STRING.

;     (CHAR CL-PPCRE::STR CL-PPCRE::I)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; in: DEFMETHOD COMPUTE-MIN-REST (ALTERNATION T)
;     (LOOP CL-PPCRE::FOR CL-PPCRE::CHOICE CL-PPCRE::IN (CL-PPCRE::CHOICES
;                                                        CL-PPCRE::ALTERNATION)
;           CL-PPCRE::MINIMIZE (CL-PPCRE::COMPUTE-MIN-REST CL-PPCRE::CHOICE
;                               CL-PPCRE::CURRENT-MIN-REST))
; --> LET SB-LOOP::WITH-MINIMAX-VALUE LET TAGBODY 
; --> SB-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN IF OR LET IF < IF 
; ==>
;   (< #:LOOP-MAXMIN-TEMP-10 #:LOOP-MAXMIN-9)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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.
; 
; 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.

; in: DEFMETHOD COMPUTE-MIN-REST (BRANCH T)
;     (MIN
;      (CL-PPCRE::COMPUTE-MIN-REST (CL-PPCRE::THEN-REGEX CL-PPCRE::BRANCH)
;       CL-PPCRE::CURRENT-MIN-REST)
;      (CL-PPCRE::COMPUTE-MIN-REST (CL-PPCRE::ELSE-REGEX CL-PPCRE::BRANCH)
;       CL-PPCRE::CURRENT-MIN-REST))
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; 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.
; 
; note: forced to do GENERIC-= (cost 10)
;       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.
;       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.

; in: DEFMETHOD COMPUTE-MIN-REST (STR T)
;     (+ CL-PPCRE::CURRENT-MIN-REST (CL-PPCRE::LEN CL-PPCRE::STR))
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; 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
;                                                                &OPTIONAL).
;       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
;                                                                &OPTIONAL).
;       etc.

; in: DEFMETHOD COMPUTE-MIN-REST (FILTER T)
;     (+ CL-PPCRE::CURRENT-MIN-REST (OR (CL-PPCRE::LEN CL-PPCRE::FILTER) 0))
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; 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
;                                                                &OPTIONAL).
;       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
;                                                                &OPTIONAL).
;       etc.

; in: DEFMETHOD COMPUTE-MIN-REST (REPETITION T)
;     (* (CL-PPCRE::MINIMUM CL-PPCRE::REPETITION)
;        (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION))
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

;     (+ CL-PPCRE::CURRENT-MIN-REST
;        (* (CL-PPCRE::MINIMUM CL-PPCRE::REPETITION)
;           (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION)))
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

;     (* (CL-PPCRE::MINIMUM CL-PPCRE::REPETITION)
;        (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &OPTIONAL).
;       etc.

;     (+ CL-PPCRE::CURRENT-MIN-REST
;        (* (CL-PPCRE::MINIMUM CL-PPCRE::REPETITION)
;           (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION)))
; 
; 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
;                                                                &OPTIONAL).
;       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
;                                                                &OPTIONAL).
;       etc.

; in: DEFMETHOD COMPUTE-MIN-REST (LOOKBEHIND T)
;     (+ CL-PPCRE::CURRENT-MIN-REST (CL-PPCRE::LEN CL-PPCRE::LOOKBEHIND))
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; 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
;                                                                &OPTIONAL).
;       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
;                                                                &OPTIONAL).
;       etc.

; in: DEFMETHOD COMPUTE-MIN-REST (REGEX T)
;     (1+ CL-PPCRE::CURRENT-MIN-REST)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/cl-ppcre/optimize-tmp7S8Z6FGF.fasl
; compilation finished in 0:00:00.088
; compiling file "/usr/share/common-lisp/source/cl-ppcre/closures.lisp" (written 07 APR 2020 10:50:13 PM):

; file: /usr/share/common-lisp/source/cl-ppcre/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.

; in: DEFMETHOD CREATE-MATCHER-AUX (LOOKBEHIND T)
;     (- CL-PPCRE::START-POS CL-PPCRE::LEN)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first result of inline (signed-byte 64) arithmetic
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first result of inline (signed-byte 64) arithmetic

; in: DEFMETHOD CREATE-MATCHER-AUX (CHAR-CLASS T)
;     (CL-PPCRE::INSERT-CHAR-CLASS-TESTER (CL-PPCRE::CHAR-CLASS
;                                          (SCHAR CL-PPCRE::*STRING*
;                                                 CL-PPCRE::START-POS))
;       (LAMBDA (CL-PPCRE::START-POS)
;         (DECLARE (FIXNUM CL-PPCRE::START-POS))
;         (AND (< CL-PPCRE::START-POS CL-PPCRE::*END-POS*)
;              (CL-PPCRE::CHAR-CLASS-TEST)
;              (FUNCALL CL-PPCRE::NEXT-FN (1+ CL-PPCRE::START-POS)))))
; --> LET LAMBDA FUNCTION AND IF IF FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

; in: DEFMETHOD CREATE-MATCHER-AUX (STR T)
;     (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::START-POS) 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.

;     (LENGTH CL-PPCRE::END-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR CONS VECTOR
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

;     (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::END-STRING CL-PPCRE::START-POS
;      CL-PPCRE::TEST-END-POS 0 CL-PPCRE::END-STRING-LEN)
; --> BLOCK LOOP BLOCK LET LET TAGBODY UNLESS IF CHAR-EQUAL 
; ==>
;   1
; 
; 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::*STRING*-EQUAL CL-PPCRE::STR CL-PPCRE::START-POS
;      CL-PPCRE::NEXT-POS 0 CL-PPCRE::LEN)
; --> BLOCK LOOP BLOCK LET LET TAGBODY UNLESS IF CHAR-EQUAL 
; ==>
;   1
; 
; 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::START-POS CL-PPCRE::LEN)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first result of inline (signed-byte 64) arithmetic
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first result of inline (signed-byte 64) arithmetic
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first result of inline (signed-byte 64) arithmetic

; in: DEFMETHOD CREATE-MATCHER-AUX (BACK-REFERENCE T)
;     (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::*STRING* CL-PPCRE::START-POS
;      CL-PPCRE::NEXT-POS CL-PPCRE::REG-START CL-PPCRE::REG-END)
; --> BLOCK LOOP BLOCK LET LET TAGBODY UNLESS IF CHAR-EQUAL 
; ==>
;   1
; 
; 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.

; in: DEFMETHOD CREATE-MATCHER-AUX (FILTER T)
;     (FUNCALL CL-PPCRE::FN CL-PPCRE::START-POS)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   FN is not known to be a function

;     (FUNCALL CL-PPCRE::NEXT-FN CL-PPCRE::NEXT-POS)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   NEXT-FN is not known to be a function


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/cl-ppcre/closures-tmpSIT3QPKP.fasl
; compilation finished in 0:00:00.139
; compiling file "/usr/share/common-lisp/source/cl-ppcre/repetition-closures.lisp" (written 07 APR 2020 10:50:15 PM):

; file: /usr/share/common-lisp/source/cl-ppcre/repetition-closures.lisp
; 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))
;       (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE (CL-PPCRE::CHAR-CLASS-TEST)))
; --> LET CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET BLOCK 
; --> TAGBODY WHEN IF FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

;     (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::*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 TAGBODY UNLESS IF CHAR-EQUAL 
; ==>
;   1
; 
; 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::GREEDY-CONSTANT-LENGTH-CLOSURE
;      (FUNCALL CL-PPCRE::INNER-MATCHER CL-PPCRE::CURR-POS))
; --> LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       etc.

; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -13835058055282163709
;                                13835058055282163712), not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775808
;                                 9223372036854775806), not a FIXNUM.

;     (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CHAR/= #\Newline (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -13835058055282163709
;                                13835058055282163712), not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775808
;                                 9223372036854775806), not a FIXNUM.

;     (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CL-PPCRE::*STRING*= CL-PPCRE::STR CL-PPCRE::CURR-POS
;                           (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN) 0 CL-PPCRE::LEN))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -13835058055282163709
;                                13835058055282163712), not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775808
;                                 9223372036854775806), not a FIXNUM.

;     (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CHAR= CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -13835058055282163709
;                                13835058055282163712), not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775808
;                                 9223372036854775806), not a FIXNUM.

;     (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -13835058055282163709
;                                13835058055282163712), not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775808
;                                 9223372036854775806), not a FIXNUM.

; --> LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       etc.

;     (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CHAR= CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       etc.

;     (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STR CL-PPCRE::CURR-POS
;                                (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN) 0
;                                CL-PPCRE::LEN))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -13835058055282163709
;                                13835058055282163712), not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775808
;                                 9223372036854775806), not a FIXNUM.

; --> LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       etc.

;     (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CL-PPCRE::*STRING*= CL-PPCRE::STR CL-PPCRE::CURR-POS
;                           (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN) 0 CL-PPCRE::LEN))
; --> LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       etc.

;     (CL-PPCRE::INSERT-CHAR-CLASS-TESTER (CL-PPCRE::REGEX
;                                          (SCHAR CL-PPCRE::*STRING*
;                                                 CL-PPCRE::CURR-POS))
;       (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE (CL-PPCRE::CHAR-CLASS-TEST)))
; --> LET CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -13835058055282163709
;                                13835058055282163712), not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775808
;                                 9223372036854775806), not a FIXNUM.

; --> LET CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       etc.

;     (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CHAR/= #\Newline (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       etc.

;     (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
;      (FUNCALL CL-PPCRE::INNER-MATCHER CL-PPCRE::CURR-POS))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC->

;     (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CHAR/= #\Newline (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC->

;     (CL-PPCRE::INSERT-CHAR-CLASS-TESTER (CL-PPCRE::REGEX
;                                          (SCHAR CL-PPCRE::*STRING*
;                                                 CL-PPCRE::CURR-POS))
;       (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE (CL-PPCRE::CHAR-CLASS-TEST)))
; --> LET CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC->

;     (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CL-PPCRE::*STRING*= CL-PPCRE::STR CL-PPCRE::CURR-POS
;                           (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN) 0 CL-PPCRE::LEN))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC->

;     (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STR CL-PPCRE::CURR-POS
;                                (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN) 0
;                                CL-PPCRE::LEN))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC->

;     (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CHAR= CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC->

;     (CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC->

; in: DEFMETHOD CREATE-GREEDY-NO-ZERO-MATCHER (REPETITION T)
;     (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) 0)
; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; 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))
; --> + AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; 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))
; --> SB-IMPL::XSUBTRACT AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; 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)
; --> SETF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; 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))
; --> + AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; 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))
; --> SB-IMPL::XSUBTRACT AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; 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))
;       (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE (CL-PPCRE::CHAR-CLASS-TEST)))
; --> LET CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET 
; --> LOOP BLOCK LET LET TAGBODY UNLESS IF FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

;     (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::*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 TAGBODY UNLESS IF CHAR-EQUAL 
; ==>
;   1
; 
; 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::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CL-PPCRE::*STRING*= CL-PPCRE::STR CL-PPCRE::CURR-POS
;                           (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN) 0 CL-PPCRE::LEN))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -13835058055282163709
;                                13835058055282163712), not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775808
;                                 9223372036854775806), not a FIXNUM.

;     (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STR CL-PPCRE::CURR-POS
;                                (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN) 0
;                                CL-PPCRE::LEN))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -13835058055282163709
;                                13835058055282163712), not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775808
;                                 9223372036854775806), not a FIXNUM.

;     (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CHAR= CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       etc.

; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -13835058055282163709
;                                13835058055282163712), not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775808
;                                 9223372036854775806), not a FIXNUM.

;     (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       etc.

; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -13835058055282163709
;                                13835058055282163712), not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775808
;                                 9223372036854775806), not a FIXNUM.

;     (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STR CL-PPCRE::CURR-POS
;                                (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN) 0
;                                CL-PPCRE::LEN))
; --> LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       etc.

;     (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CL-PPCRE::*STRING*= CL-PPCRE::STR CL-PPCRE::CURR-POS
;                           (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN) 0 CL-PPCRE::LEN))
; --> LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       etc.

;     (CL-PPCRE::INSERT-CHAR-CLASS-TESTER (CL-PPCRE::REGEX
;                                          (SCHAR CL-PPCRE::*STRING*
;                                                 CL-PPCRE::CURR-POS))
;       (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE (CL-PPCRE::CHAR-CLASS-TEST)))
; --> LET CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET 
; --> MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -13835058055282163709
;                                13835058055282163712), not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775808
;                                 9223372036854775806), not a FIXNUM.

; --> LET CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET 
; --> 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       etc.

;     (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE T)
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -13835058055282163709
;                                13835058055282163712), not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775808
;                                 9223372036854775806), not a FIXNUM.

; --> LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       etc.

;     (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CHAR/= #\Newline (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -13835058055282163709
;                                13835058055282163712), not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775808
;                                 9223372036854775806), not a FIXNUM.

; --> LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       etc.

;     (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
;      (FUNCALL CL-PPCRE::INNER-MATCHER CL-PPCRE::CURR-POS))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -13835058055282163709
;                                13835058055282163712), not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775808
;                                 9223372036854775806), not a FIXNUM.

; --> LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 7)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a FIXNUM.
;       etc.

; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC->

;     (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CHAR/= #\Newline (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC->

;     (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE T)
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC->

;     (CL-PPCRE::INSERT-CHAR-CLASS-TESTER (CL-PPCRE::REGEX
;                                          (SCHAR CL-PPCRE::*STRING*
;                                                 CL-PPCRE::CURR-POS))
;       (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE (CL-PPCRE::CHAR-CLASS-TEST)))
; --> LET CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET 
; --> MIN 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC->

;     (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CL-PPCRE::*STRING*= CL-PPCRE::STR CL-PPCRE::CURR-POS
;                           (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN) 0 CL-PPCRE::LEN))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC->

;     (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CL-PPCRE::*STRING*-EQUAL CL-PPCRE::STR CL-PPCRE::CURR-POS
;                                (+ CL-PPCRE::CURR-POS CL-PPCRE::LEN) 0
;                                CL-PPCRE::LEN))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC->

;     (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CHAR= CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC->

;     (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE
;      (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS)))
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC->

; in: DEFMETHOD CREATE-NON-GREEDY-NO-ZERO-MATCHER (REPETITION T)
;     (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) 0)
; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; 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))
; --> + AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; 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))
; --> SB-IMPL::XSUBTRACT AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; 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)
; --> SETF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; 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))
; --> + AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; 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))
; --> SB-IMPL::XSUBTRACT AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; in:
;      DEFMETHOD CREATE-CONSTANT-REPETITION-CONSTANT-LENGTH-MATCHER (REPETITION T)
;     (CL-PPCRE::INSERT-CHAR-CLASS-TESTER (CL-PPCRE::REGEX
;                                          (SCHAR CL-PPCRE::*STRING*
;                                                 CL-PPCRE::CURR-POS))
;       (CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE
;        (AND (CL-PPCRE::CHAR-CLASS-TEST) (1+ CL-PPCRE::CURR-POS))))
; --> LET CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE LAMBDA FUNCTION 
; --> LET AND IF IF LOOP BLOCK LET TAGBODY UNLESS IF AND IF FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

;     (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::*STRING*-EQUAL CL-PPCRE::STR CL-PPCRE::CURR-POS CL-PPCRE::NEXT-POS
;                               0 CL-PPCRE::LEN)
; --> BLOCK LOOP BLOCK LET LET TAGBODY UNLESS IF CHAR-EQUAL 
; ==>
;   1
; 
; 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.

; in: DEFMETHOD CREATE-CONSTANT-REPETITION-MATCHER (REPETITION T)
;     (SETF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM) 0)
; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; 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))
; --> + AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; 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))
; --> SB-IMPL::XSUBTRACT AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; 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)
; --> SETF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

;     (ZEROP (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION))
; 
; 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
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (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)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; 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))
; --> + AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; 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))
; --> SB-IMPL::XSUBTRACT AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.

; in: DEFMETHOD CREATE-MATCHER-AUX (REPETITION T)
;     (ZEROP CL-PPCRE::MAXIMUM)
; 
; 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
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to open code because: The operands might not be the same type.

;     (= CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM 1)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX 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
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a (OR (COMPLEX SINGLE-FLOAT)
;                                                        (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to open code because: The operands might not be the same type.

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

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

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

;     (= CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM 1)
; 
; note: forced to do GENERIC-= (cost 10)
;       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 (COMPLEX DOUBLE-FLOAT).
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       etc.

;     (EQL CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM)
; 
; note: forced to do IF-EQL (cost 15)
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       etc.
; 
; note: forced to do IF-EQL (cost 15)
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       etc.

;     (PLUSP CL-PPCRE::MIN-LEN)
; 
; 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)
; 
; 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::MIN-LEN)
; 
; 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.


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/cl-ppcre/repetition-closures-tmpE0PA0714.fasl
; compilation finished in 0:00:00.301
; compiling file "/usr/share/common-lisp/source/cl-ppcre/scanner.lisp" (written 07 APR 2020 10:50:15 PM):

; file: /usr/share/common-lisp/source/cl-ppcre/scanner.lisp
; in: DEFUN CREATE-BMH-MATCHER
;     (CL-PPCRE::BMH-MATCHER-AUX :CASE-INSENSITIVE-P T)
; --> FUNCTION IF LOOP BLOCK LET TAGBODY LOOP BLOCK LET LET TAGBODY UNLESS IF 
; --> AND IF CHAR-EQUAL 
; ==>
;   1
; 
; 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 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
;   open code
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFUN CREATE-CHAR-SEARCHER
;     (CL-PPCRE::CHAR-SEARCHER-AUX :CASE-INSENSITIVE-P T)
; --> FUNCTION AND IF LOOP BLOCK LET LET TAGBODY WHEN IF SETQ THE AND IF 
; --> CHAR-EQUAL 
; ==>
;   1
; 
; 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.

; in: DEFUN CREATE-SCANNER-AUX
;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS) CL-PPCRE::POS))
; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF < 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF 
; ==>
;   (< (+ 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ THE 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF AND IF 
; --> NOT 
; ==>
;   1
; 
; 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-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (DECLARE (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* #)
;         (RETURN-FROM CL-PPCRE:SCAN NIL))
;       CL-PPCRE::POS))
; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF AND IF 
; --> NOT 
; ==>
;   1
; 
; 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF < 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF 
; ==>
;   (< (+ 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ THE 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (UNLESS (SETQ CL-PPCRE::POS #) (RETURN-FROM CL-PPCRE:SCAN NIL))
;       CL-PPCRE::POS))
; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF AND IF 
; --> NOT 
; ==>
;   1
; 
; 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF < 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF 
; ==>
;   (< (+ 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ THE 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (DECLARE (FUNCTION CL-PPCRE::START-STRING-TEST))
;       (UNLESS (SETQ CL-PPCRE::POS #) (RETURN-FROM CL-PPCRE:SCAN NIL))
;       CL-PPCRE::POS))
; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF AND IF 
; --> NOT 
; ==>
;   1
; 
; 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF < 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF 
; ==>
;   (< (+ 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ THE 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (DECLARE (FUNCTION CL-PPCRE::END-STRING-TEST))
;       (UNLESS (SETQ 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* #)
;         (RETURN-FROM CL-PPCRE:SCAN NIL))
;       CL-PPCRE::POS))
; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF AND IF 
; --> NOT 
; ==>
;   1
; 
; 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF < 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF 
; ==>
;   (< (+ 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ THE 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (DECLARE (FUNCTION CL-PPCRE::START-STRING-TEST CL-PPCRE::END-STRING-TEST))
;       (UNLESS (SETQ 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* #)
;         (RETURN-FROM CL-PPCRE:SCAN NIL))
;       CL-PPCRE::POS))
; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF AND IF 
; --> NOT 
; ==>
;   1
; 
; 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF < 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF 
; ==>
;   (< (+ 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ THE 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (DECLARE (FIXNUM CL-PPCRE::END-STRING-OFFSET)
;                (FUNCTION CL-PPCRE::END-STRING-TEST))
;       (LOOP (UNLESS (SETQ #) (RETURN-FROM CL-PPCRE:SCAN NIL))
;             (LOCALLY
;              (DECLARE #)
;              (WHEN # #)
;              (LET #
;                #)))))
; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF AND IF 
; --> NOT 
; ==>
;   1
; 
; 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF < 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF 
; ==>
;   (< (+ 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ THE 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (DECLARE (FIXNUM CL-PPCRE::END-STRING-OFFSET CL-PPCRE::STARTS-WITH-LEN)
;                (FUNCTION CL-PPCRE::START-STRING-TEST CL-PPCRE::END-STRING-TEST))
;       (LOOP (UNLESS (SETQ #) (RETURN-FROM CL-PPCRE:SCAN NIL))
;             (LOCALLY
;              (DECLARE #)
;              (WHEN # #)
;              (LET #
;                #)))))
; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF LOCALLY COND IF AND IF 
; --> NOT 
; ==>
;   1
; 
; 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF < 
; ==>
;   (+ CL-PPCRE::*END-STRING-POS* CL-PPCRE::END-STRING-LEN)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF 
; ==>
;   (< (+ 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ THE 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS) CL-PPCRE::POS))
; --> FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF <= 
; ==>
;   1
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (UNLESS (SETQ CL-PPCRE::POS #) (RETURN-FROM CL-PPCRE:SCAN NIL))
;       CL-PPCRE::POS))
; --> FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF <= 
; ==>
;   1
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (DECLARE (FUNCTION CL-PPCRE::END-STRING-TEST))
;       (UNLESS (SETQ 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* #)
;         (RETURN-FROM CL-PPCRE:SCAN NIL))
;       CL-PPCRE::POS))
; --> FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF <= 
; ==>
;   1
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (DECLARE (FIXNUM CL-PPCRE::END-STRING-OFFSET)
;                (FUNCTION CL-PPCRE::END-STRING-TEST))
;       (LOOP (UNLESS (SETQ #) (RETURN-FROM CL-PPCRE:SCAN NIL))
;             (LOCALLY
;              (DECLARE #)
;              (WHEN # #)
;              (LET #
;                #)))))
; --> FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF <= 
; ==>
;   1
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (DECLARE (FUNCTION CL-PPCRE::START-STRING-TEST CL-PPCRE::END-STRING-TEST))
;       (UNLESS (SETQ 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* #)
;         (RETURN-FROM CL-PPCRE:SCAN NIL))
;       CL-PPCRE::POS))
; --> FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF <= 
; ==>
;   1
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (DECLARE (FUNCTION CL-PPCRE::START-STRING-TEST))
;       (UNLESS (SETQ CL-PPCRE::POS #) (RETURN-FROM CL-PPCRE:SCAN NIL))
;       CL-PPCRE::POS))
; --> FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF <= 
; ==>
;   1
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (DECLARE (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* #)
;         (RETURN-FROM CL-PPCRE:SCAN NIL))
;       CL-PPCRE::POS))
; --> FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF <= 
; ==>
;   1
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (DECLARE (FIXNUM CL-PPCRE::END-STRING-OFFSET CL-PPCRE::STARTS-WITH-LEN)
;                (FUNCTION CL-PPCRE::START-STRING-TEST CL-PPCRE::END-STRING-TEST))
;       (LOOP (UNLESS (SETQ #) (RETURN-FROM CL-PPCRE:SCAN NIL))
;             (LOCALLY
;              (DECLARE #)
;              (WHEN # #)
;              (LET #
;                #)))))
; --> FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF <= 
; ==>
;   1
; 
; note: unable to open code because: The operands might not be the same type.
; 
; 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF < 
; ==>
;   (+ 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 REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT
;                                                              &OPTIONAL).
;       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 REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                              &OPTIONAL).
;       etc.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF 
; ==>
;   (< (+ 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ THE 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (DECLARE (FIXNUM CL-PPCRE::END-STRING-OFFSET)
;                (FUNCTION CL-PPCRE::END-STRING-TEST))
;       (LOOP (UNLESS (SETQ #) (RETURN-FROM CL-PPCRE:SCAN NIL))
;             (LOCALLY
;              (DECLARE #)
;              (WHEN # #)
;              (LET #
;                #)))))
; --> FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF <= 
; ==>
;   1
; 
; 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF < 
; ==>
;   (+ 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 REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT
;                                                              &OPTIONAL).
;       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 REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                              &OPTIONAL).
;       etc.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF 
; ==>
;   (< (+ 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ THE 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (DECLARE (FUNCTION CL-PPCRE::START-STRING-TEST CL-PPCRE::END-STRING-TEST))
;       (UNLESS (SETQ 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* #)
;         (RETURN-FROM CL-PPCRE:SCAN NIL))
;       CL-PPCRE::POS))
; --> FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF <= 
; ==>
;   1
; 
; 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF < 
; ==>
;   (+ 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 REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT
;                                                              &OPTIONAL).
;       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 REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                              &OPTIONAL).
;       etc.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF 
; ==>
;   (< (+ 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ THE 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (DECLARE (FUNCTION CL-PPCRE::END-STRING-TEST))
;       (UNLESS (SETQ 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* #)
;         (RETURN-FROM CL-PPCRE:SCAN NIL))
;       CL-PPCRE::POS))
; --> FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF <= 
; ==>
;   1
; 
; 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF < 
; ==>
;   (+ 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 REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT
;                                                              &OPTIONAL).
;       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 REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                              &OPTIONAL).
;       etc.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF 
; ==>
;   (< (+ 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ THE 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (DECLARE (FUNCTION CL-PPCRE::START-STRING-TEST))
;       (UNLESS (SETQ CL-PPCRE::POS #) (RETURN-FROM CL-PPCRE:SCAN NIL))
;       CL-PPCRE::POS))
; --> FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF <= 
; ==>
;   1
; 
; 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF < 
; ==>
;   (+ 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 REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT
;                                                              &OPTIONAL).
;       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 REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                              &OPTIONAL).
;       etc.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF 
; ==>
;   (< (+ 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ THE 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (UNLESS (SETQ CL-PPCRE::POS #) (RETURN-FROM CL-PPCRE:SCAN NIL))
;       CL-PPCRE::POS))
; --> FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF <= 
; ==>
;   1
; 
; 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF < 
; ==>
;   (+ 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 REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT
;                                                              &OPTIONAL).
;       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 REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                              &OPTIONAL).
;       etc.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF 
; ==>
;   (< (+ 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ THE 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS)
;       (DECLARE (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* #)
;         (RETURN-FROM CL-PPCRE:SCAN NIL))
;       CL-PPCRE::POS))
; --> FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF <= 
; ==>
;   1
; 
; 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF < 
; ==>
;   (+ 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 REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT
;                                                              &OPTIONAL).
;       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 REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                              &OPTIONAL).
;       etc.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF 
; ==>
;   (< (+ 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ THE 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (CL-PPCRE::INSERT-ADVANCE-FN
;      (CL-PPCRE::ADVANCE-FN (CL-PPCRE::POS) CL-PPCRE::POS))
; --> FUNCTION BLOCK LET* LABELS WHEN IF PROGN UNLESS IF AND IF <= 
; ==>
;   1
; 
; 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF < 
; ==>
;   (+ 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 REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT
;                                                              &OPTIONAL).
;       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 REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                              &OPTIONAL).
;       etc.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF AND IF 
; ==>
;   (< (+ 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.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ THE 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

;     (FUNCALL CL-PPCRE::END-STRING-TEST CL-PPCRE::TRY-POS)
; 
; note: doing signed word to integer coercion (cost 20) from TRY-POS
; 
; note: doing signed word to integer coercion (cost 20) from TRY-POS


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/cl-ppcre/scanner-tmpJRWHHVG0.fasl
; compilation finished in 0:00:00.504
; compiling file "/usr/share/common-lisp/source/cl-ppcre/api.lisp" (written 07 APR 2020 10:50:13 PM):

; file: /usr/share/common-lisp/source/cl-ppcre/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 VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; in: DEFMETHOD CREATE-SCANNER (T)
;     (PLUSP (CL-PPCRE::LEN CL-PPCRE::END-STRING))
; 
; 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))
; 
; 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
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (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))
; 
; 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))
; 
; 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
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (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))
; 
; 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))
; 
; 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.

; 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 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)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

;     (CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING CL-PPCRE::TARGET-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST
;                               (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
;                                    (NOT SIMPLE-BASE-STRING) VECTOR)
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND (NOT SIMPLE-BASE-STRING)
;                                     (NOT (SIMPLE-ARRAY CHARACTER (*))) VECTOR)
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
;                                                                     * (*)).

; 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 VECTOR.

;     (CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING CL-PPCRE::TARGET-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST
;                               (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
;                                    (NOT SIMPLE-BASE-STRING) VECTOR)
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND (NOT SIMPLE-BASE-STRING)
;                                     (NOT (SIMPLE-ARRAY CHARACTER (*))) VECTOR)
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
;                                                                     * (*)).

; 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 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)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

;     (CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING CL-PPCRE::TARGET-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST
;                               (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
;                                    (NOT SIMPLE-BASE-STRING) VECTOR)
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND (NOT SIMPLE-BASE-STRING)
;                                     (NOT (SIMPLE-ARRAY CHARACTER (*))) VECTOR)
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
;                                                                     * (*)).

; in: DEFUN SCAN-TO-STRINGS
;     (LENGTH CL-PPCRE::TARGET-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (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)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFMACRO DO-SCANS
;     (DEFMACRO 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
;                 &OPTIONAL
;                 CL-PPCRE::RESULT-FORM
;                 &KEY
;                 CL-PPCRE::START
;                 CL-PPCRE::END)
;                &BODY CL-PPCRE::BODY &ENVIRONMENT CL-PPCRE::ENV)
;       #<(SIMPLE-ARRAY CHARACTER
;          (495)) Iterates over TARGET-STRING and tries to match REGEX as often as
;   possible evaluating BODY with MATCH-START, MATCH-END, REG-STARTS, and
;   REG-ENDS bound to the four return values of each match in turn.  ... {10028ECB8F}>
;       (CL-PPCRE::WITH-REBINDING (CL-PPCRE::TARGET-STRING)
;         (CL-PPCRE::WITH-UNIQUE-NAMES (CL-PPCRE::%START CL-PPCRE::%END
;                                       CL-PPCRE::%REGEX CL-PPCRE::SCANNER)
;           (DECLARE (IGNORABLE CL-PPCRE::%REGEX CL-PPCRE::SCANNER))
;           `(BLOCK NIL
;              (LET* #
;                #
;                #)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (MATCH-START MATCH-END
;                                                      REG-STARTS REG-ENDS REGEX
;                                                      TARGET-STRING &OPTIONAL
;                                                      RESULT-FORM &KEY START END)

; in: DEFMACRO DO-MATCHES
;     (DEFMACRO CL-PPCRE:DO-MATCHES
;               (
;                (CL-PPCRE::MATCH-START
;                 CL-PPCRE::MATCH-END
;                 CL-PPCRE::REGEX
;                 CL-PPCRE::TARGET-STRING
;                 &OPTIONAL
;                 CL-PPCRE::RESULT-FORM
;                 &KEY
;                 CL-PPCRE::START
;                 CL-PPCRE::END)
;                &BODY CL-PPCRE::BODY)
;       #<(SIMPLE-ARRAY CHARACTER
;          (477)) Iterates over TARGET-STRING and tries to match REGEX as often as
;   possible evaluating BODY with MATCH-START and MATCH-END bound to the
;   start/end positions of each match in turn.  After the last match,
;   ... {1002D56F0F}>
;       (CL-PPCRE::WITH-UNIQUE-NAMES (CL-PPCRE::REG-STARTS CL-PPCRE::REG-ENDS)
;         `(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
;                              ,CL-PPCRE::RESULT-FORM :START ,CL-PPCRE::START :END
;                              ,CL-PPCRE::END)
;            ,@CL-PPCRE::BODY)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (MATCH-START MATCH-END REGEX
;                                                      TARGET-STRING &OPTIONAL
;                                                      RESULT-FORM &KEY START END)

; in: DEFMACRO DO-MATCHES-AS-STRINGS
;     (DEFMACRO CL-PPCRE:DO-MATCHES-AS-STRINGS
;               (
;                (CL-PPCRE::MATCH-VAR
;                 CL-PPCRE::REGEX
;                 CL-PPCRE::TARGET-STRING
;                 &OPTIONAL
;                 CL-PPCRE::RESULT-FORM
;                 &KEY
;                 CL-PPCRE::START
;                 CL-PPCRE::END
;                 CL-PPCRE::SHAREDP)
;                &BODY CL-PPCRE::BODY)
;       #<(SIMPLE-ARRAY CHARACTER
;          (569)) Iterates over TARGET-STRING and tries to match REGEX as often as
;   possible evaluating BODY with MATCH-VAR bound to the substring of
;   TARGET-STRING corresponding to each match in turn.  After the last
;   ma... {1002EE653F}>
;       (CL-PPCRE::WITH-REBINDING (CL-PPCRE::TARGET-STRING)
;         (CL-PPCRE::WITH-UNIQUE-NAMES (CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
;                                       CL-PPCRE::SUBSTR-FN)
;           `(LET (#)
;              (CL-PPCRE:DO-MATCHES #
;                #)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (MATCH-VAR REGEX
;                                                      TARGET-STRING &OPTIONAL
;                                                      RESULT-FORM &KEY START END
;                                                      SHAREDP)

; in: DEFMACRO DO-REGISTER-GROUPS
;     (DEFMACRO CL-PPCRE:DO-REGISTER-GROUPS
;               (CL-PPCRE::VAR-LIST
;                (CL-PPCRE::REGEX
;                 CL-PPCRE::TARGET-STRING
;                 &OPTIONAL
;                 CL-PPCRE::RESULT-FORM
;                 &KEY
;                 CL-PPCRE::START
;                 CL-PPCRE::END
;                 CL-PPCRE::SHAREDP)
;                &BODY CL-PPCRE::BODY)
;       #<(SIMPLE-ARRAY CHARACTER
;          (820)) Iterates over TARGET-STRING and tries to match REGEX as often as
;   possible evaluating BODY with the variables in VAR-LIST bound to the
;   corresponding register groups for each match in turn, i.e. each
;   va... {10030DD9DF}>
;       (CL-PPCRE::WITH-REBINDING (CL-PPCRE::TARGET-STRING)
;         (CL-PPCRE::WITH-UNIQUE-NAMES (CL-PPCRE::SUBSTR-FN CL-PPCRE::MATCH-START
;                                       CL-PPCRE::MATCH-END CL-PPCRE::REG-STARTS
;                                       CL-PPCRE::REG-ENDS CL-PPCRE::START-INDEX)
;           `(LET (#)
;              (CL-PPCRE:DO-SCANS #
;                #)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (REGEX TARGET-STRING
;                                                            &OPTIONAL RESULT-FORM
;                                                            &KEY START END SHAREDP)

; in: DEFUN ALL-MATCHES
;     (LENGTH CL-PPCRE::TARGET-STRING)
; 
; 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))
; --> LET BLOCK LET* OR LET IF 
; ==>
;   (LENGTH #:TARGET-STRING3)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> LET BLOCK LET* SETQ THE CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING LET COND 
; --> IF THE COERCE 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST
;                               (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
;                                    (NOT SIMPLE-BASE-STRING) VECTOR)
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND (NOT SIMPLE-BASE-STRING)
;                                     (NOT (SIMPLE-ARRAY CHARACTER (*))) VECTOR)
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
;                                                                     * (*)).

; --> LET BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 
; ==>
;   (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX 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
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

; --> LET BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 1+ 
; ==>
;   1
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a (OR (COMPLEX SINGLE-FLOAT)
;                                                        (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a RATIONAL.

; --> LET BLOCK LET* LOOP BLOCK TAGBODY PROGN 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 DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       etc.

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

; in: DEFUN ALL-MATCHES-AS-STRINGS
;     (LENGTH CL-PPCRE::TARGET-STRING)
; 
; 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 CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* OR LET IF 
; ==>
;   (LENGTH #:TARGET-STRING7)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* SETQ THE 
; --> CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING LET COND IF THE COERCE 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST
;                               (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
;                                    (NOT SIMPLE-BASE-STRING) VECTOR)
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND (NOT SIMPLE-BASE-STRING)
;                                     (NOT (SIMPLE-ARRAY CHARACTER (*))) VECTOR)
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
;                                                                     * (*)).

; --> LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* LOOP BLOCK 
; --> TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION SETQ THE 
; --> IF 
; ==>
;   (= #:MATCH-START2 #:MATCH-END3)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX 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
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

; --> LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* LOOP BLOCK 
; --> TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION SETQ THE 
; --> IF 1+ 
; ==>
;   1
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a (OR (COMPLEX SINGLE-FLOAT)
;                                                        (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a RATIONAL.

; --> LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* LOOP BLOCK 
; --> TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION SETQ THE 
; --> IF 
; ==>
;   (= #:MATCH-START2 #:MATCH-END3)
; 
; note: forced to do GENERIC-= (cost 10)
;       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 (COMPLEX DOUBLE-FLOAT).
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       etc.

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

; in: DEFUN SPLIT
;     (LENGTH CL-PPCRE::TARGET-STRING)
; 
; 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)))
; --> BLOCK LET* OR LET IF 
; ==>
;   (LENGTH #:TARGET-STRING1)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK LET* SETQ THE CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING LET COND IF 
; --> THE COERCE 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST
;                               (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
;                                    (NOT SIMPLE-BASE-STRING) VECTOR)
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND (NOT SIMPLE-BASE-STRING)
;                                     (NOT (SIMPLE-ARRAY CHARACTER (*))) VECTOR)
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
;                                                                     * (*)).

;     (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX 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
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a (COMPLEX 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 (OR REAL COMPLEX), not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a (OR (COMPLEX SINGLE-FLOAT)
;                                                        (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

;     (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 ...)
; --> LET LET LET LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; ==>
;   1
; 
; 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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; 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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (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)))
; --> BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 
; ==>
;   (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX 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
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

; --> BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 1+ 
; ==>
;   1
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a (OR (COMPLEX SINGLE-FLOAT)
;                                                        (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a RATIONAL.

;     (> CL-PPCRE::THIS-END CL-PPCRE::THIS-START)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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.

;     (>= (INCF CL-PPCRE::COUNTER) CL-PPCRE::LIMIT)
; 
; note: unable to open code because: The operands might not be the same type.

;     (= 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 DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       etc.

;     (= 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 (OR REAL COMPLEX), not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR REAL COMPLEX), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       etc.

;     (INCF CL-PPCRE::COUNTER)
; --> THE 
; ==>
;   (+ 1 CL-PPCRE::COUNTER)
; 
; 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
;                                                                     &OPTIONAL).
;       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
;                                                                     &OPTIONAL).
;       etc.

;     (>= (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)))
; --> BLOCK LET* LOOP BLOCK TAGBODY PROGN 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 DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       etc.

; --> BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 1+ 
; ==>
;   1
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (OR REAL COMPLEX), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR REAL COMPLEX), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       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.

; in: DEFUN STRING-CASE-MODIFIER
;     (CHAR CL-PPCRE::STR (1- CL-PPCRE::FROM))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (CHAR CL-PPCRE::STR CL-PPCRE::FROM)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (CHAR CL-PPCRE::STR CL-PPCRE::TO)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (CHAR CL-PPCRE::STR (1- CL-PPCRE::TO))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (CHAR CL-PPCRE::STR CL-PPCRE::INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; in: DEFMETHOD BUILD-REPLACEMENT-TEMPLATE (STRING)
;     (POSITION-IF #'CL-PPCRE::DIGIT-CHAR-P CL-PPCRE::REPLACEMENT-STRING :START
;                  CL-PPCRE::MATCH-START :END CL-PPCRE::MATCH-END)
; 
; 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))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (< 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))
; 
; 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
;                                                                 &OPTIONAL).
;       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
;                                                                 &OPTIONAL).
;       etc.

;     (< CL-PPCRE::TOKEN 0)
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; in: DEFUN BUILD-REPLACEMENT
;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::REG-START
;                        CL-PPCRE::REG-END)
; --> MAKE-ARRAY 
; ==>
;   (- CL-PPCRE::END CL-PPCRE::START)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

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

;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START
;                        CL-PPCRE::MATCH-END)
; 
; note: unable to optimize because: ELEMENT-TYPE is not constant.

;     (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)
; 
; note: unable to open code because: can't determine sequence argument type

;     (APPLY CL-PPCRE::TOKEN
;            (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START
;                               CL-PPCRE::MATCH-END)
;            (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))
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START
;                        CL-PPCRE::MATCH-END)
; --> MAKE-ARRAY 
; ==>
;   (- CL-PPCRE::END CL-PPCRE::START)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

;     (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)
; 
; note: unable to open code because: can't determine sequence argument type

;     (FUNCALL CL-PPCRE::TOKEN CL-PPCRE::TARGET-STRING CL-PPCRE::START
;              CL-PPCRE::END CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END
;              CL-PPCRE::REG-STARTS CL-PPCRE::REG-ENDS)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::REG-START
;                        CL-PPCRE::REG-END)
; --> MAKE-ARRAY 
; ==>
;   (- CL-PPCRE::END CL-PPCRE::START)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START
;                        CL-PPCRE::MATCH-END)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.

; ==>
;   (MAKE-ARRAY (- CL-PPCRE::END CL-PPCRE::START) :ELEMENT-TYPE
;               (ARRAY-ELEMENT-TYPE SEQUENCE) :DISPLACED-TO SEQUENCE
;               :DISPLACED-INDEX-OFFSET CL-PPCRE::START)
; 
; note: unable to optimize because: ELEMENT-TYPE is not constant.

;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::REG-START
;                        CL-PPCRE::REG-END)
; ==>
;   (MAKE-ARRAY (- CL-PPCRE::END CL-PPCRE::START) :ELEMENT-TYPE
;               (ARRAY-ELEMENT-TYPE SEQUENCE) :DISPLACED-TO SEQUENCE
;               :DISPLACED-INDEX-OFFSET CL-PPCRE::START)
; 
; note: unable to optimize because: ELEMENT-TYPE is not constant.
; 
; note: unable to optimize because: ELEMENT-TYPE is not constant.

;     (WITH-OUTPUT-TO-STRING (CL-PPCRE::S NIL :ELEMENT-TYPE CL-PPCRE::ELEMENT-TYPE)
;       (LOOP CL-PPCRE::FOR CL-PPCRE::TOKEN CL-PPCRE::IN CL-PPCRE::REPLACEMENT-TEMPLATE
;             DO (TYPECASE CL-PPCRE::TOKEN
;                  (STRING (WRITE-STRING CL-PPCRE::TOKEN CL-PPCRE::S))
;                  (INTEGER (WHEN # #) (WHEN # #))
;                  (FUNCTION (WRITE-STRING # CL-PPCRE::S))
;                  (SYMBOL (CASE CL-PPCRE::TOKEN # # # # #)))))
; --> LET 
; ==>
;   (MAKE-STRING 31 :ELEMENT-TYPE CL-PPCRE::ELEMENT-TYPE)
; 
; note: could not stack allocate:
;        (WITH-OUTPUT-TO-STRING (S NIL :ELEMENT-TYPE ELEMENT-TYPE)
;          (LOOP FOR TOKEN IN REPLACEMENT-TEMPLATE
;                DO (TYPECASE TOKEN
;                     (STRING (WRITE-STRING TOKEN S))
;                     (INTEGER
;                      (WHEN (>= TOKEN REG-BOUND)
;                        (SIGNAL-INVOCATION-ERROR
;                         "Reference to non-existent register ~A in replacement string."
;                         (1+ TOKEN)))
;                      (WHEN (SVREF REG-STARTS TOKEN)
;                        (WRITE-STRING TARGET-STRING S :START
;                                      (SVREF REG-STARTS TOKEN) :END
;                                      (SVREF REG-ENDS TOKEN))))
;                     (FUNCTION
;                      (WRITE-STRING
;                       (COND
;                        (SIMPLE-CALLS
;                         (APPLY TOKEN
;                                (NSUBSEQ TARGET-STRING MATCH-START MATCH-END)
;                                (MAP 'LIST
;                                     (LAMBDA (REG-START REG-END)
;                                       (AND REG-START
;                                            (NSUBSEQ TARGET-STRING REG-START
;                                                     REG-END)))
;                                     REG-STARTS REG-ENDS)))
;                        (T
;                         (FUNCALL TOKEN TARGET-STRING START END MATCH-START
;                                  MATCH-END REG-STARTS REG-ENDS)))
;                       S))
;                     (SYMBOL
;                      (CASE TOKEN
;                        ((:BACKSLASH) (WRITE-CHAR #\\ S))
;                        ((:MATCH)
;                         (WRITE-STRING TARGET-STRING S :START MATCH-START :END
;                                       MATCH-END))
;                        ((:BEFORE-MATCH)
;                         (WRITE-STRING TARGET-STRING S :START START :END
;                                       MATCH-START))
;                        ((:AFTER-MATCH)
;                         (WRITE-STRING TARGET-STRING S :START MATCH-END :END
;                                       END))
;                        (OTHERWISE
;                         (WRITE-STRING
;                          (COND
;                           (SIMPLE-CALLS
;                            (APPLY TOKEN
;                                   (NSUBSEQ TARGET-STRING MATCH-START MATCH-END)
;                                   (MAP 'LIST
;                                        (LAMBDA (REG-START REG-END)
;                                          (AND REG-START
;                                               (NSUBSEQ TARGET-STRING REG-START
;                                                        REG-END)))
;                                        REG-STARTS REG-ENDS)))
;                           (T
;                            (FUNCALL TOKEN TARGET-STRING START END MATCH-START
;                                     MATCH-END REG-STARTS REG-ENDS)))
;                          S)))))))

;     (1+ CL-PPCRE::TOKEN)
; 
; 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
;                                                                     &OPTIONAL).
;       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
;                                                                     &OPTIONAL).
;       etc.

;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START
;                        CL-PPCRE::MATCH-END)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       etc.

; --> MAKE-ARRAY 
; ==>
;   (- CL-PPCRE::END CL-PPCRE::START)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       etc.

;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::REG-START
;                        CL-PPCRE::REG-END)
; --> MAKE-ARRAY 
; ==>
;   (- CL-PPCRE::END CL-PPCRE::START)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       etc.

; in: DEFUN REPLACE-AUX
;     (WITH-OUTPUT-TO-STRING (CL-PPCRE::S NIL :ELEMENT-TYPE CL-PPCRE::ELEMENT-TYPE)
;       (LOOP CL-PPCRE::FOR (CL-PPCRE::FROM CL-PPCRE::TO) CL-PPCRE::ON (APPEND
;                                                                       (LIST
;                                                                        CL-PPCRE::START)
;                                                                       CL-PPCRE::POS-LIST
;                                                                       (LIST
;                                                                        CL-PPCRE::END))
;             CL-PPCRE::FOR REPLACE = NIL CL-PPCRE::THEN (AND (NOT REPLACE)
;                                                             CL-PPCRE::TO)
;             CL-PPCRE::FOR ...))
; --> LET 
; ==>
;   (MAKE-STRING 31 :ELEMENT-TYPE CL-PPCRE::ELEMENT-TYPE)
; 
; note: could not stack allocate:
;        (WITH-OUTPUT-TO-STRING (S NIL :ELEMENT-TYPE ELEMENT-TYPE)
;          (LOOP FOR (FROM TO) ON (APPEND (LIST START) POS-LIST (LIST END))
;                FOR REPLACE = NIL THEN (AND (NOT REPLACE) TO)
;                FOR REG-STARTS = (IF REPLACE
;                                     (POP REG-LIST)
;                                     NIL)
;                FOR REG-ENDS = (IF REPLACE
;                                   (POP REG-LIST)
;                                   NIL)
;                FOR CURR-REPLACEMENT = (IF REPLACE
;                                           (BUILD-REPLACEMENT
;                                            REPLACEMENT-TEMPLATE TARGET-STRING
;                                            START END FROM TO REG-STARTS
;                                            REG-ENDS SIMPLE-CALLS ELEMENT-TYPE)
;                                           NIL)
;                WHILE TO
;                IF REPLACE
;                DO (WRITE-STRING
;                    (IF PRESERVE-CASE
;                        (FUNCALL
;                         (STRING-CASE-MODIFIER TARGET-STRING FROM TO START END)
;                         CURR-REPLACEMENT)
;                        CURR-REPLACEMENT)
;                    S) ELSE
;                DO (WRITE-STRING TARGET-STRING S :START FROM :END TO)))

; in: DEFUN REGEX-REPLACE
;     (LENGTH CL-PPCRE::TARGET-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (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 VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; in: DEFUN REGEX-REPLACE-ALL
;     (LENGTH CL-PPCRE::TARGET-STRING)
; 
; 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))
; --> BLOCK LET* OR LET IF 
; ==>
;   (LENGTH #:TARGET-STRING1)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK LET* SETQ THE CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING LET COND IF 
; --> THE COERCE 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST
;                               (AND (NOT (SIMPLE-ARRAY CHARACTER (*)))
;                                    (NOT SIMPLE-BASE-STRING) VECTOR)
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND (NOT SIMPLE-BASE-STRING)
;                                     (NOT (SIMPLE-ARRAY CHARACTER (*))) VECTOR)
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
;                                                                     * (*)).

; --> BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 
; ==>
;   (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; 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
;   open-code float conversion in mixed numeric operation
; 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 conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX 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
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

; --> BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ THE IF 1+ 
; ==>
;   1
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a (OR (COMPLEX SINGLE-FLOAT)
;                                                        (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a (OR REAL COMPLEX), not a RATIONAL.

;     (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 VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (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))
; --> BLOCK LET* LOOP BLOCK TAGBODY PROGN 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 DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       etc.

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

; 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)))
;       #<(SIMPLE-ARRAY CHARACTER
;          (221)) 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-insensi... {1002BBE8CF}>
;       (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))))
; --> 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))
;       #<(SIMPLE-ARRAY CHARACTER
;          (221)) 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-insensi... {1002BBE8CF}>
;       (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: DEFUN REGEX-APROPOS
;     (DEFUN CL-PPCRE:REGEX-APROPOS
;            (CL-PPCRE::REGEX
;             &OPTIONAL CL-PPCRE::PACKAGES
;             &KEY (CL-PPCRE::CASE-INSENSITIVE T))
;       #<(SIMPLE-ARRAY CHARACTER
;          (216)) 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 ... {100310A3AF}>
;       (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))
; --> 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))
;       #<(SIMPLE-ARRAY CHARACTER
;          (216)) 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 ... {100310A3AF}>
;       (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))


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/cl-ppcre/api-tmp4WZVROCX.fasl
; compilation finished in 0:00:00.373
WARNING:
   Lisp compilation had style-warnings while
   compiling #<CL-SOURCE-FILE "cl-ppcre" "api">
; compiling file "/usr/share/common-lisp/source/clx/package.lisp" (written 01 NOV 2018 12:58:32 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/package-tmpA0I3UKX8.fasl
; compilation finished in 0:00:00.042
; compiling file "/usr/share/common-lisp/source/clx/depdefs.lisp" (written 01 NOV 2018 12:58:27 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/depdefs-tmp267Y2N80.fasl
; compilation finished in 0:00:00.175
; compiling file "/usr/share/common-lisp/source/clx/clx.lisp" (written 01 NOV 2018 12:58:25 PM):

; file: /usr/share/common-lisp/source/clx/clx.lisp
; in: DEFUN ENCODE-EVENT-MASK
;     (XLIB::X-TYPE-ERROR XLIB:EVENT-MASK 'XLIB:EVENT-MASK)
; 
; note: deleting unreachable code

; in: DEFUN ENCODE-DEVICE-EVENT-MASK
;     (XLIB::X-TYPE-ERROR XLIB:DEVICE-EVENT-MASK 'XLIB:DEVICE-EVENT-MASK)
; 
; note: deleting unreachable code

; in: DEFUN ENCODE-MODIFIER-MASK
;     (XLIB::X-TYPE-ERROR XLIB:MODIFIER-MASK 'XLIB:MODIFIER-MASK)
; 
; note: deleting unreachable code

; in: DEFUN ENCODE-STATE-MASK
;     (XLIB::X-TYPE-ERROR XLIB::STATE-MASK
;      '(OR XLIB:MASK16 (XLIB::CLX-LIST XLIB:STATE-MASK-KEY)))
; 
; note: deleting unreachable code

; in: DEFUN ENCODE-POINTER-EVENT-MASK
;     (XLIB::X-TYPE-ERROR XLIB:POINTER-EVENT-MASK 'XLIB:POINTER-EVENT-MASK)
; 
; note: deleting unreachable code


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/clx-tmpOUPE5FSJ.fasl
; compilation finished in 0:00:00.806
; compiling file "/usr/share/common-lisp/source/clx/dependent.lisp" (written 01 NOV 2018 12:58:27 PM):

; file: /usr/share/common-lisp/source/clx/dependent.lisp
; in: DEFMACRO HOLDING-LOCK
;     (DEFMACRO XLIB::HOLDING-LOCK
;               (
;                (XLIB::LOCK
;                 XLIB:DISPLAY
;                 &OPTIONAL
;                 (XLIB::WHOSTATE "CLX wait")
;                 &KEY
;                 XLIB::TIMEOUT)
;                &BODY XLIB::BODY)
;       (DECLARE (IGNORE XLIB:DISPLAY XLIB::WHOSTATE))
;       (IF XLIB::TIMEOUT
;           `(IF ,XLIB::TIMEOUT
;                (HANDLER-CASE
;                 (WITH-TIMEOUT ,XLIB::TIMEOUT
;                   #)
;                 (TIMEOUT NIL NIL))
;                (SB-THREAD:WITH-RECURSIVE-LOCK (,XLIB::LOCK)
;                  ,@XLIB::BODY))
;           `(SB-THREAD:WITH-RECURSIVE-LOCK (,XLIB::LOCK)
;              ,@XLIB::BODY)))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (LOCK DISPLAY &OPTIONAL
;                                                      (WHOSTATE CLX wait) &KEY
;                                                      TIMEOUT)

; in: DEFMACRO READ-IMAGE-LOAD-BYTE
;     (SETQ POSITION (- 7 POSITION))
; 
; note: deleting unreachable code

; in: DEFMACRO READ-IMAGE-ASSEMBLE-BYTES
;     (SETQ XLIB::BYTES (REVERSE XLIB::BYTES))
; 
; note: deleting unreachable code

; in: DEFMACRO WRITE-IMAGE-LOAD-BYTE
;     (- XLIB::INTEGER-SIZE 8 POSITION)
; 
; note: deleting unreachable code

; in: DEFMACRO WRITE-IMAGE-ASSEMBLE-BYTES
;     (SETQ XLIB::BYTES (REVERSE XLIB::BYTES))
; 
; note: deleting unreachable code

; in: DEFUN FAST-READ-PIXARRAY
;     (XLIB::READ-PIXARRAY-INTERNAL XLIB::BBUF XLIB::BOFFSET XLIB:PIXARRAY XLIB::X
;      XLIB::Y XLIB::WIDTH XLIB::HEIGHT XLIB::PADDED-BYTES-PER-LINE
;      XLIB::BITS-PER-PIXEL FUNCTION XLIB::UNIT ...)
; 
; note: deleting unreachable code

; in: DEFUN FAST-WRITE-PIXARRAY-USING-BITBLT
;     (ARRAY-DIMENSION XLIB:PIXARRAY 1)
; 
; note: unable to
;   optimize
; because:
;   The array dimensions are unknown; must call ARRAY-DIMENSION at runtime.

; in: DEFUN FAST-WRITE-PIXARRAY
;     (XLIB::WRITE-PIXARRAY-INTERNAL XLIB::BBUF XLIB::BOFFSET XLIB:PIXARRAY XLIB::X
;      XLIB::Y XLIB::WIDTH XLIB::HEIGHT XLIB::PADDED-BYTES-PER-LINE
;      XLIB::BITS-PER-PIXEL FUNCTION XLIB::+IMAGE-UNIT+ ...)
; 
; note: deleting unreachable code


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/dependent-tmpIGHCU6ZA.fasl
; compilation finished in 0:00:00.243
WARNING:
   Lisp compilation had style-warnings while
   compiling #<CLX-SOURCE-FILE "clx" "dependent">
; compiling file "/usr/share/common-lisp/source/clx/macros.lisp" (written 01 NOV 2018 12:58:32 PM):

; file: /usr/share/common-lisp/source/clx/macros.lisp
; in: DEFMACRO DEFINE-ACCESSOR
;     (THIRD XLIB::GET-PUT-MACROS)
; 
; note: deleting unreachable code


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/macros-tmpBO0TUGLK.fasl
; compilation finished in 0:00:00.470
; compiling file "/usr/share/common-lisp/source/clx/bufmac.lisp" (written 01 NOV 2018 12:58:24 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/bufmac-tmpIIXPIQNW.fasl
; compilation finished in 0:00:00.034
; compiling file "/usr/share/common-lisp/source/clx/buffer.lisp" (written 01 NOV 2018 12:58:24 PM):

; file: /usr/share/common-lisp/source/clx/buffer.lisp
; in: DEFUN WITH-BUFFER-FUNCTION
;     (XLIB::WITH-BUFFER (XLIB::BUFFER :TIMEOUT XLIB::TIMEOUT :INLINE T)
;       (FUNCALL FUNCTION))
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE FLET #:FORM-FUN-3 BLOCK PROGN 
; --> WITH-TIMEOUT SB-INT:DX-FLET FLET LET IF 
; ==>
;   (> SB-IMPL::EXPIRES 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.

; in: DEFUN READ-VECTOR-CARD8
;     (SETF (AREF XLIB::DATA XLIB::J) (XLIB::READ-CARD8 XLIB::INDEX))
; --> FUNCALL 
; ==>
;   1
; 
; 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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFUN READ-VECTOR-CARD8-WITH-TRANSFORM
;     (SETF (AREF XLIB::DATA XLIB::J)
;             (FUNCALL XLIB::TRANSFORM (XLIB::READ-CARD8 XLIB::INDEX)))
; --> FUNCALL 
; ==>
;   1
; 
; 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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFUN READ-VECTOR-CARD16
;     (SETF (AREF XLIB::DATA XLIB::J) (XLIB::READ-CARD16 XLIB::INDEX))
; --> FUNCALL 
; ==>
;   1
; 
; 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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFUN READ-VECTOR-CARD16-WITH-TRANSFORM
;     (SETF (AREF XLIB::DATA XLIB::J)
;             (FUNCALL XLIB::TRANSFORM (XLIB::READ-CARD16 XLIB::INDEX)))
; --> FUNCALL 
; ==>
;   1
; 
; 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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFUN READ-VECTOR-CARD32
;     (SETF (AREF XLIB::DATA XLIB::J) (XLIB::READ-CARD32 XLIB::INDEX))
; --> FUNCALL 
; ==>
;   1
; 
; 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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFUN READ-VECTOR-CARD32-WITH-TRANSFORM
;     (SETF (AREF XLIB::DATA XLIB::J)
;             (FUNCALL XLIB::TRANSFORM (XLIB::READ-CARD32 XLIB::INDEX)))
; --> FUNCALL 
; ==>
;   1
; 
; 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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFUN WRITE-VECTOR-CARD8
;     (AREF XLIB::DATA XLIB::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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFUN WRITE-VECTOR-CARD8-WITH-TRANSFORM
;     (AREF XLIB::DATA XLIB::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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFUN WRITE-VECTOR-CARD16
;     (AREF XLIB::DATA XLIB::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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFUN WRITE-VECTOR-CARD16-WITH-TRANSFORM
;     (AREF XLIB::DATA XLIB::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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFUN WRITE-VECTOR-INT16
;     (AREF XLIB::DATA XLIB::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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFUN WRITE-VECTOR-INT16-WITH-TRANSFORM
;     (AREF XLIB::DATA XLIB::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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFUN WRITE-VECTOR-CARD32
;     (AREF XLIB::DATA XLIB::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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFUN WRITE-VECTOR-CARD32-WITH-TRANSFORM
;     (AREF XLIB::DATA XLIB::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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFUN WRITE-VECTOR-CHAR2B
;     (AREF XLIB::DATA XLIB::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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFUN WRITE-VECTOR-CHAR2B-WITH-TRANSFORM
;     (AREF XLIB::DATA XLIB::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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/buffer-tmpOHM494YR.fasl
; compilation finished in 0:00:00.891
; compiling file "/usr/share/common-lisp/source/clx/display.lisp" (written 01 NOV 2018 12:58:28 PM):

; file: /usr/share/common-lisp/source/clx/display.lisp
; in: DEFUN DISPLAY-CONNECT
;     (LENGTH XLIB::AUTHORIZATION-NAME)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (LENGTH XLIB::AUTHORIZATION-DATA)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (LENGTH XLIB::AUTHORIZATION-NAME)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/display-tmpOVFB07XF.fasl
; compilation finished in 0:00:00.211
; compiling file "/usr/share/common-lisp/source/clx/gcontext.lisp" (written 01 NOV 2018 12:58:29 PM):

; file: /usr/share/common-lisp/source/clx/gcontext.lisp
; in: DEFUN FORCE-GCONTEXT-CHANGES-INTERNAL
;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-SETCLIPRECTANGLES+)
;       (XLIB::DATA (FIRST XLIB::LOCAL-CLIP))
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       (XLIB:CARD16 (OR (XLIB::GCONTEXT-INTERNAL-CLIP-X XLIB::LOCAL-STATE) 0)
;        (OR (XLIB::GCONTEXT-INTERNAL-CLIP-Y XLIB::LOCAL-STATE) 0))
;       ((SEQUENCE :FORMAT XLIB:INT16) (SECOND XLIB::LOCAL-CLIP)))
; --> XLIB::WITH-BUFFER PROGN MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN 
; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET* 
; --> XLIB::CHECK-PUT LET XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::.VALUE.)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (LENGTH XLIB::LOCAL-DASH)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR CONS VECTOR
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-SETDASHES+)
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       (XLIB:CARD16 (OR (XLIB::GCONTEXT-INTERNAL-DASH-OFFSET XLIB::LOCAL-STATE) 0)
;        (LENGTH XLIB::LOCAL-DASH))
;       ((SEQUENCE :FORMAT XLIB:CARD8) XLIB::LOCAL-DASH))
; --> XLIB::WITH-BUFFER PROGN MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN 
; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET* 
; --> XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::LOCAL-DASH)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR CONS VECTOR
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

;     (FUNCALL (XLIB::GCONTEXT-EXTENSION-SET-FUNCTION (CAR XLIB::EXTENSION))
;              XLIB:GCONTEXT XLIB::LOCAL)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

;     (EQL (SVREF XLIB::SERVER-STATE XLIB::I)
;          (SETQ XLIB::LOCAL (SVREF XLIB::LOCAL-STATE XLIB::I)))
; 
; note: forced to do IF-EQL (cost 15)
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       etc.

; in: DEFUN COPY-GCONTEXT-LOCAL-STATE
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:GCONTEXT 'XLIB:GCONTEXT)
; --> XLIB::WITH-BUFFER PROGN FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

;     (- XLIB::*GCONTEXT-DATA-LENGTH*)
; 
; note: unable to
;   Eliminate %negate/%negate of rationals
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (ELT XLIB::*GCONTEXT-EXTENSIONS* XLIB::I)
; 
; 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.

;     (FUNCALL XLIB::COPY-FUNCTION XLIB:GCONTEXT XLIB::TEMP-GC
;              (SVREF XLIB::LOCAL-STATE
;                     (XLIB::INDEX+ XLIB::I XLIB::*GCONTEXT-DATA-LENGTH*)))
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

;     (- XLIB::*GCONTEXT-DATA-LENGTH*)
; 
; note: forced to do GENERIC-NEGATE (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 INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (signed-byte 64) arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (SIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (ASH XLIB::EXTENSION-MASK (- XLIB::*GCONTEXT-DATA-LENGTH*))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline ASH (cost 4) because:
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

;     (ASH BIT -1)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (OR (INTEGER * -1) (INTEGER 1)), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (OR (INTEGER * -1) (INTEGER 1)), not a (UNSIGNED-BYTE
;                                                                       64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

; in: DEFUN RESTORE-GCONTEXT-TEMP-STATE
;     (- XLIB::*GCONTEXT-DATA-LENGTH*)
; 
; note: unable to
;   Eliminate %negate/%negate of rationals
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (FUNCALL XLIB::COPY-FUNCTION XLIB::TEMP-GC XLIB:GCONTEXT
;              (SVREF XLIB::LOCAL-STATE XLIB::I))
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

;     (- XLIB::*GCONTEXT-DATA-LENGTH*)
; 
; note: forced to do GENERIC-NEGATE (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 INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (signed-byte 64) arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (SIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (ASH XLIB::TEMP-MASK (- XLIB::*GCONTEXT-DATA-LENGTH*))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline ASH (cost 4) because:
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

;     (ASH BIT -1)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (OR (INTEGER * -1) (INTEGER 1)), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (OR (INTEGER * -1) (INTEGER 1)), not a (UNSIGNED-BYTE
;                                                                       64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

; in: DEFUN CREATE-GCONTEXT
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:GCONTEXT 'XLIB:GCONTEXT)
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

; in: DEFUN COPY-GCONTEXT-COMPONENTS
;     (FIND XLIB::KEY XLIB::*GCONTEXT-EXTENSIONS* :KEY
;           #'XLIB::GCONTEXT-EXTENSION-NAME)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR LIST VECTOR).

;     (FUNCALL (XLIB::GCONTEXT-EXTENSION-COPY-FUNCTION XLIB::EXTENSION) XLIB::SRC
;              XLIB::DST
;              (SVREF (XLIB::GCONTEXT-LOCAL-STATE XLIB::SRC)
;                     (XLIB::INDEX+
;                      (POSITION XLIB::EXTENSION XLIB::*GCONTEXT-EXTENSIONS*)
;                      XLIB::*GCONTEXT-DATA-LENGTH*)))
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

;     (POSITION XLIB::EXTENSION XLIB::*GCONTEXT-EXTENSIONS*)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR LIST VECTOR).


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/gcontext-tmpG6VFGMYP.fasl
; compilation finished in 0:00:00.722
; compiling file "/usr/share/common-lisp/source/clx/input.lisp" (written 01 NOV 2018 12:58:31 PM):

; file: /usr/share/common-lisp/source/clx/input.lisp
; in: DEFUN READ-INPUT
;     (CONS NIL NIL)
; 
; note: deleting unreachable code

; in: DEFUN QUEUE-EVENT
;     (APPLY (SVREF XLIB::*EVENT-SEND-VECTOR* XLIB::EVENT-CODE) XLIB:DISPLAY
;            XLIB::ARGS)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

; in: DECLARE-EVENT :CLIENT-MESSAGE
;     (XLIB:DECLARE-EVENT :CLIENT-MESSAGE
;       (XLIB::DATA FORMAT)
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW))
;       (KEYWORD TYPE)
;       ((XLIB::CLIENT-MESSAGE-SEQUENCE FORMAT) XLIB::DATA))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION BLOCK XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* 
; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (SIMPLE-ARRAY * (*)), 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 (SIMPLE-ARRAY * (*)), 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 (SIMPLE-ARRAY * (*)), 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 because: ELEMENT-TYPE is not constant.

; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION BLOCK XLIB::WITH-BUFFER-OUTPUT LET LET* 
; --> XLIB::CLIENT-MESSAGE-SEQUENCE-PUT XLIB::CLIENT-MESSAGE-EVENT-PUT-SEQUENCE 
; --> ECASE LET COND IF PROGN XLIB::SEQUENCE-PUT XLIB::WRITE-SEQUENCE-CARD8 MIN 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION BLOCK XLIB::WITH-BUFFER-OUTPUT LET LET* 
; --> XLIB::CLIENT-MESSAGE-SEQUENCE-PUT XLIB::CLIENT-MESSAGE-EVENT-PUT-SEQUENCE 
; --> ECASE LET COND IF IF PROGN XLIB::SEQUENCE-PUT XLIB::WRITE-SEQUENCE-CARD16 
; --> MIN 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION BLOCK XLIB::WITH-BUFFER-OUTPUT LET LET* 
; --> XLIB::CLIENT-MESSAGE-SEQUENCE-PUT XLIB::CLIENT-MESSAGE-EVENT-PUT-SEQUENCE 
; --> ECASE LET COND IF IF IF PROGN XLIB::SEQUENCE-PUT 
; --> XLIB::WRITE-SEQUENCE-CARD32 MIN 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFUN MAKE-ERROR
;     (FUNCALL XLIB::ERROR-DECODE-FUNCTION XLIB:DISPLAY XLIB::EVENT)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/input-tmp4QIPRMOF.fasl
; compilation finished in 0:00:01.117
; compiling file "/usr/share/common-lisp/source/clx/requests.lisp" (written 01 NOV 2018 12:58:33 PM):

; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN CREATE-WINDOW
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:WINDOW 'XLIB:WINDOW)
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK LET FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-CREATEWINDOW+)
;       (XLIB::DATA XLIB::DEPTH)
;       (XLIB:RESOURCE-ID XLIB::WID)
;       (XLIB:WINDOW XLIB::PARENT)
;       (XLIB:INT16 XLIB::X XLIB::Y)
;       (XLIB:CARD16 XLIB::WIDTH XLIB::HEIGHT XLIB::BORDER-WIDTH)
;       ((XLIB::MEMBER16 :COPY :INPUT-OUTPUT :INPUT-ONLY) CLASS)
;       (XLIB:RESOURCE-ID
;        (COND ((EQ XLIB::VISUAL :COPY) 0)
;              ((TYPEP XLIB::VISUAL 'XLIB:RESOURCE-ID) XLIB::VISUAL)
;              (T (XLIB:VISUAL-INFO-ID XLIB::VISUAL))))
;       (XLIB::MASK
;        (XLIB:CARD32 XLIB::BACK-PIXMAP XLIB::BACK-PIXEL XLIB::BORDER-PIXMAP
;         XLIB::BORDER-PIXEL)
;        ((XLIB::MEMBER-VECTOR XLIB::+BIT-GRAVITY-VECTOR+) XLIB:BIT-GRAVITY)
;        ((XLIB::MEMBER-VECTOR XLIB::+WIN-GRAVITY-VECTOR+) XLIB::GRAVITY)
;        ((MEMBER :NOT-USEFUL :WHEN-MAPPED :ALWAYS) XLIB::BACKING-STORE)
;        (XLIB:CARD32 XLIB::BACKING-PLANES XLIB::BACKING-PIXEL)
;        ((MEMBER :OFF :ON) XLIB::OVERRIDE-REDIRECT XLIB::SAVE-UNDER)
;        (XLIB:CARD32 XLIB:EVENT-MASK XLIB::DO-NOT-PROPAGATE-MASK)
;        ((OR (MEMBER :COPY) XLIB:COLORMAP) XLIB:COLORMAP)
;        ((OR (MEMBER :NONE) XLIB:CURSOR) XLIB:CURSOR)))
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* LET UNLESS IF PROGN SETQ THE 
; ==>
;   (LOGIOR XLIB::%MASK 2048)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 4096)
; 
; note: forced to do full call
;       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
;                                                                 &OPTIONAL).
;       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
;                                                                 &OPTIONAL).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 8192)
; 
; note: forced to do full call
;       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
;                                                                 &OPTIONAL).
;       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
;                                                                 &OPTIONAL).
;       etc.

; ==>
;   (LOGIOR XLIB::%MASK 16384)
; 
; note: forced to do full call
;       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
;                                                                 &OPTIONAL).
;       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
;                                                                 &OPTIONAL).
;       etc.

; in: DEFUN SEND-EVENT
;     (APPLY (SVREF XLIB::*EVENT-SEND-VECTOR* XLIB::INTERNAL-EVENT-CODE)
;            XLIB:DISPLAY XLIB::ARGS)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

; in: DEFUN CREATE-PIXMAP
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:PIXMAP 'XLIB:PIXMAP)
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK LET FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

; in: DEFUN CREATE-COLORMAP
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:COLORMAP 'XLIB:COLORMAP)
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK LET FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

; in: DEFUN COPY-COLORMAP-AND-FREE
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB::NEW-COLORMAP 'XLIB:COLORMAP)
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK LET FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

; in: DEFUN FREE-COLORS
;     (XLIB::WITH-BUFFER-REQUEST ((XLIB:COLORMAP-DISPLAY XLIB:COLORMAP)
;                                 XLIB::+X-FREECOLORS+)
;       (XLIB:COLORMAP XLIB:COLORMAP)
;       (XLIB:CARD32 XLIB::PLANE-MASK)
;       (SEQUENCE XLIB::PIXELS))
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::PIXELS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFUN QUERY-COLORS
;     (XLIB::WITH-BUFFER-REQUEST-AND-REPLY (XLIB:DISPLAY XLIB::+X-QUERYCOLORS+ NIL
;                                           :SIZES (8 16))
;         ((XLIB:COLORMAP XLIB:COLORMAP) (SEQUENCE XLIB::PIXELS))
;       (LET ((SEQUENCE (MAKE-SEQUENCE XLIB::RESULT-TYPE #)))
;         (XLIB::ADVANCE-BUFFER-OFFSET XLIB::+REPLYSIZE+)
;         (DOTIMES (XLIB::I (LENGTH SEQUENCE) SEQUENCE)
;           (SETF # #)
;           (XLIB::ADVANCE-BUFFER-OFFSET 8))))
; --> UNWIND-PROTECT FLET BLOCK BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN 
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK XLIB::WITHOUT-ABORTS PROGN 
; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET* 
; --> XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::PIXELS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (LENGTH SEQUENCE)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (SIMPLE-ARRAY * (*))
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

;     (SETF (ELT SEQUENCE XLIB::I)
;             (XLIB:MAKE-COLOR :RED (XLIB::RGB-VAL-GET 0) :GREEN
;                              (XLIB::RGB-VAL-GET 2) :BLUE (XLIB::RGB-VAL-GET 4)))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (SIMPLE-ARRAY * (*))
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
;                                                                    * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (SIMPLE-ARRAY * (*))
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.

; in: DEFUN CREATE-CURSOR
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:CURSOR 'XLIB:CURSOR)
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK LET FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

; in: DEFUN CREATE-GLYPH-CURSOR
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:CURSOR 'XLIB:CURSOR)
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK LET FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

; in: DEFUN SET-POINTER-MAPPING
;     (LENGTH MAP)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (XLIB::WITH-BUFFER-REQUEST-AND-REPLY (XLIB:DISPLAY
;                                           XLIB::+X-SETPOINTERMAPPING+ 2 :SIZES 8)
;         ((XLIB::DATA (LENGTH MAP)) ((SEQUENCE :FORMAT XLIB:CARD8) MAP))
;       (VALUES (XLIB::BOOLEAN-GET 1)))
; --> UNWIND-PROTECT FLET BLOCK BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN 
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK XLIB::WITHOUT-ABORTS PROGN 
; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET* 
; --> XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH MAP)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFUN CHANGE-ACCESS-HOST
;     (LENGTH XLIB::ADDRESS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-CHANGEHOSTS+)
;       ((XLIB::DATA BOOLEAN) XLIB::REMOVE-P)
;       (XLIB:CARD8
;        (XLIB::ENCODE-TYPE (OR NULL (MEMBER :INTERNET :DECNET :CHAOS) XLIB:CARD32)
;                           XLIB::FAMILY))
;       (XLIB:CARD16 (LENGTH XLIB::ADDRESS))
;       ((SEQUENCE :FORMAT XLIB:CARD8) XLIB::ADDRESS))
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::ADDRESS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFUN ACCESS-HOSTS
;     (SETF (ELT SEQUENCE XLIB::I)
;             (CONS
;              (IF (< XLIB::FAMILY 3)
;                  (SVREF '# XLIB::FAMILY)
;                  XLIB::FAMILY)
;              (XLIB::SEQUENCE-GET :LENGTH XLIB::LEN :FORMAT XLIB:CARD8
;                                  :RESULT-TYPE 'LIST :INDEX
;                                  (+ XLIB::BUFFER-BOFFSET 4))))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (SIMPLE-ARRAY * (*))
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
;                                                                    * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (SIMPLE-ARRAY * (*))
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/requests-tmpGW0QV22K.fasl
; compilation finished in 0:00:01.506
; compiling file "/usr/share/common-lisp/source/clx/fonts.lisp" (written 01 NOV 2018 12:58:29 PM):

; file: /usr/share/common-lisp/source/clx/fonts.lisp
; in: DEFUN OPEN-FONT
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:FONT 'XLIB:FONT)
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK LET FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

; in: DEFUN OPEN-FONT-INTERNAL
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:FONT 'XLIB:FONT)
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK LET FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

;     (LENGTH XLIB::NAME-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR STRING NULL), not a VECTOR.

;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-OPENFONT+)
;       (XLIB:RESOURCE-ID XLIB::ID)
;       (XLIB:CARD16 (LENGTH XLIB::NAME-STRING))
;       (XLIB::PAD16 NIL)
;       (STRING XLIB::NAME-STRING))
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::STRING-PUT LET 
; ==>
;   (LENGTH XLIB::NAME-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR STRING NULL), not a VECTOR.

; in: DEFUN SET-FONT-PATH
;     (CEILING XLIB::REQUEST-LENGTH 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert integer division to multiplication
; due to type uncertainty:
;   The first argument is a REAL, not a (SIGNED-BYTE 64).
; 
; note: unable to
;   convert integer division to multiplication
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 64).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT (RATIONAL (-4) (4))), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (ELT XLIB::PATHS XLIB::I)
; 
; 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.

;     (STRING (ELT XLIB::PATHS XLIB::I))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR STRING SYMBOL CHARACTER), not a SYMBOL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR STRING SYMBOL CHARACTER), not a STRING.

;     (CEILING XLIB::REQUEST-LENGTH 4)
; 
; 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 arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       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
;                                                                 &OPTIONAL).
;       etc.


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/fonts-tmp2K9J0HSR.fasl
; compilation finished in 0:00:00.166
; compiling file "/usr/share/common-lisp/source/clx/graphics.lisp" (written 01 NOV 2018 12:58:30 PM):

; file: /usr/share/common-lisp/source/clx/graphics.lisp
; in: DEFUN DRAW-POINTS
;     (XLIB::WITH-BUFFER-REQUEST ((XLIB:DRAWABLE-DISPLAY XLIB:DRAWABLE)
;                                 XLIB::+X-POLYPOINT+ :GC-FORCE XLIB:GCONTEXT)
;       ((XLIB::DATA BOOLEAN) XLIB::RELATIVE-P)
;       (XLIB:DRAWABLE XLIB:DRAWABLE)
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       ((SEQUENCE :FORMAT XLIB:INT16) XLIB::POINTS))
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::POINTS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFUN DRAW-LINES
;     (XLIB::WITH-BUFFER-REQUEST ((XLIB:DRAWABLE-DISPLAY XLIB:DRAWABLE)
;                                 XLIB::+X-POLYLINE+ :GC-FORCE XLIB:GCONTEXT)
;       ((XLIB::DATA BOOLEAN) XLIB::RELATIVE-P)
;       (XLIB:DRAWABLE XLIB:DRAWABLE)
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       ((SEQUENCE :FORMAT XLIB:INT16) XLIB::POINTS))
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::POINTS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFUN FILL-POLYGON
;     (XLIB::WITH-BUFFER-REQUEST ((XLIB:DRAWABLE-DISPLAY XLIB:DRAWABLE)
;                                 XLIB::+X-FILLPOLY+ :GC-FORCE XLIB:GCONTEXT)
;       (XLIB:DRAWABLE XLIB:DRAWABLE)
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       ((XLIB::MEMBER8 :COMPLEX :NON-CONVEX :CONVEX) XLIB::SHAPE)
;       (BOOLEAN XLIB::RELATIVE-P)
;       ((SEQUENCE :FORMAT XLIB:INT16) XLIB::POINTS))
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::POINTS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFUN DRAW-SEGMENTS
;     (XLIB::WITH-BUFFER-REQUEST ((XLIB:DRAWABLE-DISPLAY XLIB:DRAWABLE)
;                                 XLIB::+X-POLYSEGMENT+ :GC-FORCE XLIB:GCONTEXT)
;       (XLIB:DRAWABLE XLIB:DRAWABLE)
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       ((SEQUENCE :FORMAT XLIB:INT16) XLIB::SEGMENTS))
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::SEGMENTS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFUN DRAW-RECTANGLES
;     (XLIB::WITH-BUFFER-REQUEST ((XLIB:DRAWABLE-DISPLAY XLIB:DRAWABLE)
;                                 (IF XLIB::FILL-P
;                                     XLIB::+X-POLYFILLRECTANGLE+
;                                     XLIB::+X-POLYRECTANGLE+)
;                                 :GC-FORCE XLIB:GCONTEXT)
;       (XLIB:DRAWABLE XLIB:DRAWABLE)
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       ((SEQUENCE :FORMAT XLIB:INT16) XLIB::RECTANGLES))
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::RECTANGLES)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFUN DRAW-ARCS-VECTOR
;     (AREF XLIB::ARCS (XLIB::INDEX+ XLIB::N 0))
; 
; 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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (AREF XLIB::ARCS (XLIB::INDEX+ XLIB::N 1))
; 
; 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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (AREF XLIB::ARCS (XLIB::INDEX+ XLIB::N 2))
; 
; 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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (AREF XLIB::ARCS (XLIB::INDEX+ XLIB::N 3))
; 
; 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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (AREF XLIB::ARCS (XLIB::INDEX+ XLIB::N 4))
; 
; 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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (AREF XLIB::ARCS (XLIB::INDEX+ XLIB::N 5))
; 
; 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
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFUN PUT-RAW-IMAGE
;     (XLIB::WITH-BUFFER-REQUEST ((XLIB:DRAWABLE-DISPLAY XLIB:DRAWABLE)
;                                 XLIB::+X-PUTIMAGE+ :GC-FORCE XLIB:GCONTEXT)
;       ((XLIB::DATA (MEMBER :BITMAP :XY-PIXMAP :Z-PIXMAP)) FORMAT)
;       (XLIB:DRAWABLE XLIB:DRAWABLE)
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       (XLIB:CARD16 XLIB::WIDTH XLIB::HEIGHT)
;       (XLIB:INT16 XLIB::X XLIB::Y)
;       (XLIB:CARD8 XLIB::LEFT-PAD XLIB::DEPTH)
;       (XLIB::PAD16 NIL)
;       ((SEQUENCE :FORMAT XLIB:CARD8 :START XLIB::START) XLIB::DATA))
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::DATA)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/graphics-tmpP44I4E0Y.fasl
; compilation finished in 0:00:00.384
; compiling file "/usr/share/common-lisp/source/clx/text.lisp" (written 01 NOV 2018 12:58:34 PM):

; file: /usr/share/common-lisp/source/clx/text.lisp
; in: DEFUN TEXT-EXTENTS
;     (LENGTH SEQUENCE)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFUN TEXT-WIDTH
;     (LENGTH SEQUENCE)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (INCF XLIB::WIDTH
;           (IF (OR (XLIB::FONT-CHAR-INFOS-INTERNAL XLIB:FONT)
;                   (XLIB::FONT-LOCAL-ONLY-P XLIB:FONT))
;               (XLIB::TEXT-EXTENTS-LOCAL XLIB:FONT XLIB::WBUF 0 XLIB::BUF-END
;                :WIDTH-ONLY)
;               (XLIB::TEXT-WIDTH-SERVER XLIB:FONT XLIB::WBUF 0 XLIB::BUF-END)))
; --> THE 
; ==>
;   (+
;    (IF (OR (XLIB::FONT-CHAR-INFOS-INTERNAL XLIB:FONT)
;            (XLIB::FONT-LOCAL-ONLY-P XLIB:FONT))
;        (XLIB::TEXT-EXTENTS-LOCAL XLIB:FONT XLIB::WBUF 0 XLIB::BUF-END
;         :WIDTH-ONLY)
;        (XLIB::TEXT-WIDTH-SERVER XLIB:FONT XLIB::WBUF 0 XLIB::BUF-END))
;    XLIB::WIDTH)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       etc.

; in: DEFUN DRAW-GLYPHS8
;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-POLYTEXT8+ :GC-FORCE
;                                 XLIB:GCONTEXT :LENGTH XLIB::REQUEST-LENGTH)
;       (XLIB:DRAWABLE XLIB:DRAWABLE)
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       (XLIB:INT16 XLIB::X XLIB::Y)
;       (PROGN
;        (XLIB::WITH-BUFFER-FLUSH-INHIBITED (XLIB:DISPLAY)
;          (DO* (#
;                #
;                #
;                #
;                #
;                #)
;               (# # # # # #)
;            (DECLARE #
;                     #
;                     #)
;            (SETQ #)
;            (MULTIPLE-VALUE-BIND # # # # # # #)))))
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; ==>
;   (FLET ((SB-THREAD::WITH-RECURSIVE-LOCK-THUNK ()
;            (XLIB::FORCE-GCONTEXT-CHANGES-INTERNAL XLIB:GCONTEXT)
;            (MULTIPLE-VALUE-PROG1
;                (XLIB::WITHOUT-ABORTS
;                  #)
;              (XLIB:DISPLAY-INVOKE-AFTER-FUNCTION XLIB::.DISPLAY.))))
;     (DECLARE
;      (SB-INT:TRULY-DYNAMIC-EXTENT
;       (FUNCTION SB-THREAD::WITH-RECURSIVE-LOCK-THUNK)))
;     (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #'SB-THREAD::WITH-RECURSIVE-LOCK-THUNK
;                                          (XLIB::BUFFER-LOCK XLIB::.DISPLAY.) T
;                                          NIL))
; 
; note: doing unsigned word to integer coercion (cost 20), for:
;       the second argument of CLOSURE-INIT

; in: DEFUN DRAW-GLYPHS16
;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-POLYTEXT16+ :GC-FORCE
;                                 XLIB:GCONTEXT :LENGTH XLIB::REQUEST-LENGTH)
;       (XLIB:DRAWABLE XLIB:DRAWABLE)
;       (XLIB:GCONTEXT XLIB:GCONTEXT)
;       (XLIB:INT16 XLIB::X XLIB::Y)
;       (PROGN
;        (XLIB::WITH-BUFFER-FLUSH-INHIBITED (XLIB:DISPLAY)
;          (DO* (#
;                #
;                #
;                #
;                #
;                #)
;               (# # # # # #)
;            (DECLARE #
;                     #
;                     #)
;            (SETQ #)
;            (MULTIPLE-VALUE-BIND # # # # # # # #)))))
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET 
; ==>
;   (FLET ((SB-THREAD::WITH-RECURSIVE-LOCK-THUNK ()
;            (XLIB::FORCE-GCONTEXT-CHANGES-INTERNAL XLIB:GCONTEXT)
;            (MULTIPLE-VALUE-PROG1
;                (XLIB::WITHOUT-ABORTS
;                  #)
;              (XLIB:DISPLAY-INVOKE-AFTER-FUNCTION XLIB::.DISPLAY.))))
;     (DECLARE
;      (SB-INT:TRULY-DYNAMIC-EXTENT
;       (FUNCTION SB-THREAD::WITH-RECURSIVE-LOCK-THUNK)))
;     (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #'SB-THREAD::WITH-RECURSIVE-LOCK-THUNK
;                                          (XLIB::BUFFER-LOCK XLIB::.DISPLAY.) T
;                                          NIL))
; 
; note: doing unsigned word to integer coercion (cost 20), for:
;       the second argument of CLOSURE-INIT

; in: DEFUN CHANGE-KEYBOARD-MAPPING
;     (AREF XLIB::KEYSYMS XLIB::I XLIB::J)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.

; in: DEFUN KEYBOARD-MAPPING
;     (1+ XLIB::I)
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion in mixed numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (SETF (AREF XLIB::RESULT XLIB::I XLIB::J) (XLIB::CARD29-GET (* XLIB::J 4)))
; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.

;     (1+ XLIB::I)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/text-tmp63LQ7EX6.fasl
; compilation finished in 0:00:00.463
; compiling file "/usr/share/common-lisp/source/clx/attributes.lisp" (written 01 NOV 2018 12:58:24 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/attributes-tmp86F1A8FB.fasl
; compilation finished in 0:00:00.261
; compiling file "/usr/share/common-lisp/source/clx/translate.lisp" (written 01 NOV 2018 12:58:35 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/translate-tmpH7D4HL98.fasl
; compilation finished in 0:00:00.105
; compiling file "/usr/share/common-lisp/source/clx/keysyms.lisp" (written 01 NOV 2018 12:58:31 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/keysyms-tmpCDM7YXYI.fasl
; compilation finished in 0:00:00.028
; compiling file "/usr/share/common-lisp/source/clx/manager.lisp" (written 01 NOV 2018 12:58:32 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/manager-tmpLM57P5P.fasl
; compilation finished in 0:00:00.666
; compiling file "/usr/share/common-lisp/source/clx/image.lisp" (written 01 NOV 2018 12:58:30 PM):

; file: /usr/share/common-lisp/source/clx/image.lisp
; in: DEFUN GET-IMAGE
;     (FIND XLIB::DEPTH (XLIB:DISPLAY-PIXMAP-FORMATS XLIB:DISPLAY) :KEY
;           #'XLIB:PIXMAP-FORMAT-DEPTH)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR LIST VECTOR).

; in: DEFUN COPY-PIXARRAY
;     (MAKE-ARRAY (LIST XLIB::HEIGHT XLIB::PADDED-WIDTH) :ELEMENT-TYPE
;                 (ARRAY-ELEMENT-TYPE ARRAY))
; 
; note: unable to optimize because: ELEMENT-TYPE is not constant.


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/image-tmpZE69DN33.fasl
; compilation finished in 0:00:01.159
; compiling file "/usr/share/common-lisp/source/clx/resource.lisp" (written 01 NOV 2018 12:58:34 PM):

; file: /usr/share/common-lisp/source/clx/resource.lisp
; in: DEFUN DELETE-RESOURCE-INTERNAL
;     (SETQ XLIB::LOOSE-P NIL)
; 
; note: deleting unreachable code

; in: DEFUN MAP-RESOURCE
;     (XLIB::MAP-RESOURCE-INTERNAL XLIB::RESOURCE FUNCTION XLIB::ARGS XLIB::NAME)
; 
; note: could not stack allocate FUNCTION in:
;        (MAP-RESOURCE-INTERNAL RESOURCE FUNCTION ARGS NAME)
; 
; note: could not stack allocate FUNCTION in:
;        (MAP-RESOURCE-INTERNAL RESOURCE FUNCTION ARGS NAME)


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/resource-tmpG8099TO3.fasl
; compilation finished in 0:00:00.152
; compiling file "/usr/share/common-lisp/source/clx/extensions/shape.lisp" (written 01 NOV 2018 12:58:41 PM):

; file: /usr/share/common-lisp/source/clx/extensions/shape.lisp
; in: DEFUN SHAPE-RECTANGLES
;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY
;                                 (XLIB:EXTENSION-OPCODE XLIB:DISPLAY "SHAPE"))
;       (XLIB::DATA 1)
;       (XLIB:CARD8 (XLIB::ENCODE-SHAPE-OPERATION XLIB::OPERATION))
;       (XLIB:CARD8 (XLIB::ENCODE-SHAPE-KIND XLIB::KIND))
;       (XLIB:CARD8 (XLIB::ENCODE-SHAPE-RECTANGLE-ORDERING XLIB::ORDERING))
;       (XLIB:CARD8 0)
;       (XLIB:WINDOW XLIB:WINDOW)
;       (XLIB:INT16 XLIB::X-OFFSET)
;       (XLIB:INT16 XLIB::Y-OFFSET)
;       ((SEQUENCE :FORMAT XLIB:INT16) XLIB::RECTANGLES))
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK MULTIPLE-VALUE-PROG1 
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL 
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET 
; ==>
;   (LENGTH XLIB::RECTANGLES)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/extensions/shape-tmpTASQCYAW.fasl
; compilation finished in 0:00:00.158
; compiling file "/usr/share/common-lisp/source/clx/extensions/big-requests.lisp" (written 01 NOV 2018 12:58:41 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/extensions/big-requests-tmp35U57IV6.fasl
; compilation finished in 0:00:00.024
; compiling file "/usr/share/common-lisp/source/clx/extensions/xvidmode.lisp" (written 01 NOV 2018 12:58:42 PM):

; file: /usr/share/common-lisp/source/clx/extensions/xvidmode.lisp
; in: DEFUN XFREE86-VIDMODE-GET-GAMMA
;     (/ (THE XLIB:CARD32 (OR (XLIB::CARD32-GET 8) 0)) 10000.0)
; 
; note: unable to
;   convert to multiplication by reciprocal
; because:
;   10000.0 does not have an exact reciprocal

;     (/ (THE XLIB:CARD32 (OR (XLIB::CARD32-GET 12) 0)) 10000.0)
; 
; note: unable to
;   convert to multiplication by reciprocal
; because:
;   10000.0 does not have an exact reciprocal

;     (/ (THE XLIB:CARD32 (OR (XLIB::CARD32-GET 16) 0)) 10000.0)
; 
; note: unable to
;   convert to multiplication by reciprocal
; because:
;   10000.0 does not have an exact reciprocal


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/extensions/xvidmode-tmpTZOONXRW.fasl
; compilation finished in 0:00:00.583
; compiling file "/usr/share/common-lisp/source/clx/extensions/xrender.lisp" (written 01 NOV 2018 12:58:42 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/extensions/xrender-tmpWN0UKDSV.fasl
; compilation finished in 0:00:01.176
; compiling file "/usr/share/common-lisp/source/clx/extensions/glx.lisp" (written 01 NOV 2018 12:58:42 PM):

; file: /usr/share/common-lisp/source/clx/extensions/glx.lisp
; in: DECLARE-EVENT :GLX-PBUFFER-CLOBBER
;     (XLIB:DECLARE-EVENT :GLX-PBUFFER-CLOBBER
;       (XLIB:CARD16 SEQUENCE)
;       (XLIB:CARD16 XLIB/GLX::EVENT-TYPE)
;       (XLIB:CARD16 XLIB/GLX::DRAW-TYPE)
;       (XLIB:RESOURCE-ID XLIB:DRAWABLE)
;       (XLIB:CARD32 XLIB/GLX::BUFFER-MASK)
;       (XLIB:CARD16 XLIB/GLX::AUX-BUFFER)
;       (XLIB:CARD16 XLIB/GLX::X XLIB/GLX::Y XLIB/GLX::WIDTH XLIB/GLX::HEIGHT
;        COUNT))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES 
; ==>
;   1
; 
; note: could not stack allocate #:G52 in:
;        (DECLARE-EVENT :GLX-PBUFFER-CLOBBER
;          (CARD16 SEQUENCE)
;          (CARD16 EVENT-TYPE)
;          (CARD16 DRAW-TYPE)
;          (RESOURCE-ID DRAWABLE)
;          (CARD32 BUFFER-MASK)
;          (CARD16 AUX-BUFFER)
;          (CARD16 X Y WIDTH HEIGHT COUNT))

; in: DEFUN MAKE-CONTEXT
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB/GLX::CTX 'XLIB/GLX::CONTEXT)
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

; in: DEFUN GET-VISUAL-CONFIGS
;     (LOOP XLIB/GLX::REPEAT (/ (- XLIB/GLX::NUM-PROPERTIES XLIB/GLX::NUM-ORDERED)
;                               2)
;           XLIB/GLX::COLLECTING (CONS (XLIB::CARD32-GET (INCF XLIB/GLX::INDEX 4))
;                                      (XLIB::CARD32-GET (INCF XLIB/GLX::INDEX 4))))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (RATIONAL 1/2 4294967295/2), not a INTEGER.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a (RATIONAL 0 (1)), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (RATIONAL 0 (1)), not a FIXNUM.
;       etc.


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/extensions/glx-tmpBF3HHBTQ.fasl
; compilation finished in 0:00:00.349
; compiling file "/usr/share/common-lisp/source/clx/extensions/gl.lisp" (written 01 NOV 2018 12:58:39 PM):

; file: /usr/share/common-lisp/source/clx/extensions/gl.lisp
; in: DEFINE-SEQUENCE-SETTER INT8
;     (XLIB/GL::DEFINE-SEQUENCE-SETTER XLIB:INT8)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY LET 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY LET SB-KERNEL:ASSERT-ERROR 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFINE-SEQUENCE-SETTER INT16
;     (XLIB/GL::DEFINE-SEQUENCE-SETTER XLIB:INT16)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY LET 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY LET SB-KERNEL:ASSERT-ERROR 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFINE-SEQUENCE-SETTER INT32
;     (XLIB/GL::DEFINE-SEQUENCE-SETTER XLIB:INT32)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY LET 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY LET SB-KERNEL:ASSERT-ERROR 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFINE-SEQUENCE-SETTER BOOL
;     (XLIB/GL::DEFINE-SEQUENCE-SETTER XLIB/GL::BOOL)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY LET 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY LET SB-KERNEL:ASSERT-ERROR 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFINE-SEQUENCE-SETTER CARD8
;     (XLIB/GL::DEFINE-SEQUENCE-SETTER XLIB:CARD8)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY LET 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY LET SB-KERNEL:ASSERT-ERROR 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFINE-SEQUENCE-SETTER CARD16
;     (XLIB/GL::DEFINE-SEQUENCE-SETTER XLIB:CARD16)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY LET 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY LET SB-KERNEL:ASSERT-ERROR 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFINE-SEQUENCE-SETTER CARD32
;     (XLIB/GL::DEFINE-SEQUENCE-SETTER XLIB:CARD32)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY LET 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY LET SB-KERNEL:ASSERT-ERROR 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFINE-SEQUENCE-SETTER FLOAT32
;     (XLIB/GL::DEFINE-SEQUENCE-SETTER XLIB/GL::FLOAT32)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY LET 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY LET SB-KERNEL:ASSERT-ERROR 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; in: DEFINE-SEQUENCE-SETTER FLOAT64
;     (XLIB/GL::DEFINE-SEQUENCE-SETTER XLIB/GL::FLOAT64)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY LET 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY LET SB-KERNEL:ASSERT-ERROR 
; ==>
;   (LENGTH XLIB/GL::SEQ)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/extensions/gl-tmpGYUNPZCY.fasl
; compilation finished in 0:00:01.195
; compiling file "/usr/share/common-lisp/source/clx/extensions/dpms.lisp" (written 01 NOV 2018 12:58:42 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/extensions/dpms-tmpD68Q8WCA.fasl
; compilation finished in 0:00:00.065
; compiling file "/usr/share/common-lisp/source/clx/extensions/xtest.lisp" (written 01 NOV 2018 12:58:41 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/extensions/xtest-tmp7MK9KM9C.fasl
; compilation finished in 0:00:00.086
; compiling file "/usr/share/common-lisp/source/clx/extensions/screensaver.lisp" (written 01 NOV 2018 12:58:40 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/extensions/screensaver-tmpJJ71X849.fasl
; compilation finished in 0:00:00.018
; compiling file "/usr/share/common-lisp/source/clx/extensions/randr.lisp" (written 01 NOV 2018 12:58:40 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/extensions/randr-tmp1VUK6SR2.fasl
; compilation finished in 0:00:00.716
; compiling file "/usr/share/common-lisp/source/clx/extensions/xinerama.lisp" (written 01 NOV 2018 12:58:43 PM):

; file: /usr/share/common-lisp/source/clx/extensions/xinerama.lisp
; in: DEFUN XINERAMA-QUERY-SCREENS
;     (INCF XLIB/XINERAMA::INDEX 8)
; 
; note: doing unsigned word to integer coercion (cost 20) to INDEX


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/extensions/xinerama-tmpR2FIHSUG.fasl
; compilation finished in 0:00:00.075
; compiling file "/usr/share/common-lisp/source/clx/extensions/dbe.lisp" (written 01 NOV 2018 12:58:41 PM):

; file: /usr/share/common-lisp/source/clx/extensions/dbe.lisp
; in: DEFUN CREATE-BACK-BUFFER
;     (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB::BB 'XLIB::BACK-BUFFER)
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK 
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET 
; --> SB-THREAD::WITH-RECURSIVE-LOCK-THUNK BLOCK FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

; in: DEFUN DBE-GET-VISUAL-INFO
;     (LOOP :FOR XLIB::I :FROM 1 :TO (XLIB::CARD32-GET XLIB::NEXT)
;           :FOR XLIB::OFF := (+ XLIB::NEXT 4) :THEN ...)
; 
; note: doing unsigned word to integer coercion (cost 20) to OFF
; 
; note: doing unsigned word to integer coercion (cost 20) to OFF


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/extensions/dbe-tmp8PYELRKX.fasl
; compilation finished in 0:00:00.296
; compiling file "/usr/share/common-lisp/source/clx/extensions/xc-misc.lisp" (written 01 NOV 2018 12:58:40 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/extensions/xc-misc-tmpEHTOKYT0.fasl
; compilation finished in 0:00:00.026
; compiling file "/usr/share/common-lisp/source/clx/extensions/dri2.lisp" (written 01 NOV 2018 12:58:43 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/extensions/dri2-tmpS6U1VHI9.fasl
; compilation finished in 0:00:00.107
; compiling file "/usr/share/common-lisp/source/clx/extensions/composite.lisp" (written 01 NOV 2018 12:58:40 PM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/usr/share/common-lisp/source/clx/extensions/composite-tmpVTFK6ZJW.fasl
; compilation finished in 0:00:00.090
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/dynamic-mixins/src/package.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/dynamic-mixins/src/package-tmp75WVSJEW.fasl
; compilation finished in 0:00:00.001
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/dynamic-mixins/src/dynamic-mixins.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/dynamic-mixins/src/dynamic-mixins-tmpBU5UM3S4.fasl
; compilation finished in 0:00:00.028
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/package.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/package-tmpOBHVA3CD.fasl
; compilation finished in 0:00:00.002
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/debug.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/debug-tmpJ6ELVFLF.fasl
; compilation finished in 0:00:00.011
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/primitives.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/primitives-tmpULDB0RG.fasl
; compilation finished in 0:00:00.250
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/wrappers.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/wrappers-tmpUTZ0UUTE.fasl
; compilation finished in 0:00:00.079
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/pathnames.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/pathnames-tmpOOSRA8PZ.fasl
; compilation finished in 0:00:00.005
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/font-rendering.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/font-rendering-tmpDMIL0RVK.fasl
; compilation finished in 0:00:00.021
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/keysyms.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/keysyms-tmp8MR9IMIO.fasl
; compilation finished in 0:00:00.136
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/keytrans.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/keytrans-tmpJQDKAVAY.fasl
; compilation finished in 0:00:00.016
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/kmap.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/kmap-tmp3I8CEEQY.fasl
; compilation finished in 0:00:00.103
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/input.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/input-tmpA3RHFLWZ.fasl
; compilation finished in 0:00:00.248
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/core.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/core-tmpYZIB7VXO.fasl
; compilation finished in 0:00:00.010
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/command.lisp" (written 18 AUG 2022 03:04:11 AM):

; file: /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/command.lisp
; in: DEFUN COMMAND-ACTIVE-P
;     'STUMPWM::DYNAMIC-GROUP
; 
; note: can't open-code test of unknown type DYNAMIC-GROUP

; in: DEFUN ARGUMENT-POP
;     (LOOP STUMPWM::FOR STUMPWM::I STUMPWM::FROM STUMPWM::START STUMPWM::BELOW (LENGTH
;                                                                                STUMPWM::INPUT)
;           STUMPWM::FOR CHAR = (CHAR STUMPWM::INPUT STUMPWM::I)
;           DO ...)
; --> LET LET TAGBODY 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   The binding of I is not a REAL:
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/command-tmpR8PK79V8.fasl
; compilation finished in 0:00:00.150
WARNING:
   Lisp compilation had style-warnings while
   compiling #<CL-SOURCE-FILE "stumpwm" "command">
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/menu-declarations.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/menu-declarations-tmpN1ZVB1HZ.fasl
; compilation finished in 0:00:00.048
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/menu-definitions.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/menu-definitions-tmpZGRRPISB.fasl
; compilation finished in 0:00:00.102
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/screen.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/screen-tmpFNKDE5XP.fasl
; compilation finished in 0:00:00.066
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/head.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/head-tmpRJTU435C.fasl
; compilation finished in 0:00:00.033
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/group.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/group-tmpI9WG87JK.fasl
; compilation finished in 0:00:00.099
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/bindings.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/bindings-tmpYDE6I9E6.fasl
; compilation finished in 0:00:00.023
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/events.lisp" (written 18 AUG 2022 03:04:11 AM):

; file: /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/events.lisp
; in: DEFUN TOP-MAPS
;     'STUMPWM::DYNAMIC-GROUP
; 
; note: can't open-code test of unknown type DYNAMIC-GROUP

; in: DEFUN MAYBE-MAP-WINDOW
;     'STUMPWM::TILE-WINDOW
; 
; note: can't open-code test of unknown type TILE-WINDOW


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/events-tmp319UV2V8.fasl
; compilation finished in 0:00:00.153
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/window.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/window-tmpLYQINFYS.fasl
; compilation finished in 0:00:00.233
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/floating-group.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/floating-group-tmpGA31XWNO.fasl
; compilation finished in 0:00:00.108
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/tile-window.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/tile-window-tmp5HT23M6C.fasl
; compilation finished in 0:00:00.160
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/tile-group.lisp" (written 18 AUG 2022 03:04:11 AM):

; file: /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/tile-group.lisp
; in: DEFUN UNFLOAT-WINDOW
;     (TYPECASE STUMPWM:GROUP
;       (STUMPWM::DYNAMIC-GROUP
;        (STUMPWM::DYNAMIC-GROUP-UNFLOAT-WINDOW STUMPWM:WINDOW STUMPWM:GROUP))
;       (STUMPWM::TILE-GROUP
;        (STUMPWM::TILE-GROUP-UNFLOAT-WINDOW STUMPWM:WINDOW STUMPWM:GROUP)))
; --> COND IF 
; ==>
;   (TYPEP #:G0 'STUMPWM::DYNAMIC-GROUP)
; 
; note: can't open-code test of unknown type DYNAMIC-GROUP

; in: DEFUN FLOAT-WINDOW
;     (TYPECASE STUMPWM:GROUP
;       (STUMPWM::DYNAMIC-GROUP
;        (STUMPWM::DYNAMIC-GROUP-FLOAT-WINDOW STUMPWM:WINDOW STUMPWM:GROUP))
;       (STUMPWM::TILE-GROUP
;        (STUMPWM::TILE-GROUP-FLOAT-WINDOW STUMPWM:WINDOW STUMPWM:GROUP)))
; --> COND IF 
; ==>
;   (TYPEP #:G0 'STUMPWM::DYNAMIC-GROUP)
; 
; note: can't open-code test of unknown type DYNAMIC-GROUP


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/tile-group-tmpA60KLDKY.fasl
; compilation finished in 0:00:00.422
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/window-placement.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/window-placement-tmpD801X3GJ.fasl
; compilation finished in 0:00:00.246
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/message-window.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/message-window-tmpGOW1GC70.fasl
; compilation finished in 0:00:00.583
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/selection.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/selection-tmpPQ1X28TL.fasl
; compilation finished in 0:00:00.019
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/module.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/module-tmpE92ECU7O.fasl
; compilation finished in 0:00:00.109
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/ioloop.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/ioloop-tmp8S0II570.fasl
; compilation finished in 0:00:00.361
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/timers.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/timers-tmpJE88A12F.fasl
; compilation finished in 0:00:00.027
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/stumpwm.lisp" (written 18 AUG 2022 03:04:11 AM):

; file: /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/stumpwm.lisp
; in: DEFMETHOD HANDLE-TOP-LEVEL-CONDITION (SERIOUS-CONDITION)
;     (TYPEP STUMPWM:*CURRENT-IO-CHANNEL*
;            '(OR STUMPWM::STUMPWM-TIMER-CHANNEL STUMPWM::DISPLAY-CHANNEL
;                 STUMPWM::REQUEST-CHANNEL))
; 
; note: can't open-code test of unknown type REQUEST-CHANNEL
; 
; note: can't open-code test of unknown type DISPLAY-CHANNEL


; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/stumpwm-tmpA5FNLPLT.fasl
; compilation finished in 0:00:00.071
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/user.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/user-tmpHKCV9TP8.fasl
; compilation finished in 0:00:00.131
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/interactive-keymap.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/interactive-keymap-tmpZ18MA7XE.fasl
; compilation finished in 0:00:00.023
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/iresize.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/iresize-tmp6LQJ9T0C.fasl
; compilation finished in 0:00:00.014
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/help.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/help-tmpTX7OA81T.fasl
; compilation finished in 0:00:00.120
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/fdump.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/fdump-tmpWOTC3PB7.fasl
; compilation finished in 0:00:00.084
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/time.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/time-tmpHQE95SAC.fasl
; compilation finished in 0:00:00.038
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/mode-line.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/mode-line-tmpO87FP9NR.fasl
; compilation finished in 0:00:00.066
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/mode-line-formatters.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/mode-line-formatters-tmpP6A3E92I.fasl
; compilation finished in 0:00:00.043
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/color.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/color-tmpUSHT8RIL.fasl
; compilation finished in 0:00:00.124
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/wse.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/wse-tmp7YCPD44Y.fasl
; compilation finished in 0:00:00.024
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/dynamic-window.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/dynamic-window-tmpQXR7SNXD.fasl
; compilation finished in 0:00:00.013
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/dynamic-group.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/dynamic-group-tmp6FLI1OC3.fasl
; compilation finished in 0:00:00.389
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/remap-keys.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/remap-keys-tmpWBK8JTS9.fasl
; compilation finished in 0:00:00.015
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/manual.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/manual-tmpUVEUD2ZN.fasl
; compilation finished in 0:00:00.036
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/minor-modes.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/minor-modes-tmpOWNJOEU.fasl
; compilation finished in 0:00:00.281
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/replace-class.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/replace-class-tmpVT5BMTA5.fasl
; compilation finished in 0:00:00.025
WARNING: redefining DYNAMIC-MIXINS:REPLACE-CLASS in DEFGENERIC
; compiling file "/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/version.lisp" (written 18 AUG 2022 03:04:11 AM):

; wrote /var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/homedir/.cache/common-lisp/sbcl-2.2.9-linux-x64/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2/version-tmpN3CFVWZF.fasl
; compilation finished in 0:00:00.004
; 
; compilation unit finished
;   caught 8 STYLE-WARNING conditions
;   printed 1114 notes
[undoing binding stack and other enclosing state... done]
[performing final GC... done]
[defragmenting immobile space... (inst,fdefn,code,sym)=1064+22337+23056+27784... done]
[saving current Lisp image into stumpwm:
writing 1456 bytes from the static space at 0x50000000
writing 25886720 bytes from the dynamic space at 0x1000000000
writing 8915424 bytes from the read-only space at 0xfff778000
writing 2199552 bytes from the fixedobj space at 0x50100000
writing 14868480 bytes from the text space at 0x52a00000
done]
/usr/bin/sbcl --non-interactive --eval "(setf sb-impl::*default-external-format* :UTF-8)" --eval "(progn (load \"load-stumpwm.lisp\") (load \"manual.lisp\"))" --eval "(progn (stumpwm::generate-manual) (sb-ext:quit))"
This is SBCL 2.2.9, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.

SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses.  See the CREDITS and COPYING files in the
distribution for more information.
WARNING: redefining DYNAMIC-MIXINS:REPLACE-CLASS in DEFGENERIC
test "makeinfo" = "no" || makeinfo stumpwm.texi
/usr/bin/sbcl --non-interactive --eval "(setf sb-impl::*default-external-format* :UTF-8)" --eval "(progn (load \"load-stumpwm.lisp\") (asdf:load-system :stumpwm-tests))" --eval "(if (fiasco:all-tests) (uiop:quit 0) (uiop:quit 1))"
This is SBCL 2.2.9, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.

SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses.  See the CREDITS and COPYING files in the
distribution for more information.
WARNING: redefining DYNAMIC-MIXINS:REPLACE-CLASS in DEFGENERIC
Unhandled ASDF/FIND-COMPONENT:MISSING-DEPENDENCY in thread #<SB-THREAD:THREAD "main thread" RUNNING
                                                              {1004628113}>:
  Component "fiasco" not found, required by #<SYSTEM "stumpwm-tests">

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {1004628113}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK Component "fiasco" not found, required by #<SYSTEM "stumpwm-tests"> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* Component "fiasco" not found, required by #<SYSTEM "stumpwm-tests">)
2: (INVOKE-DEBUGGER Component "fiasco" not found, required by #<SYSTEM "stumpwm-tests">)
3: (ERROR ASDF/FIND-COMPONENT:MISSING-DEPENDENCY :REQUIRED-BY #<ASDF/SYSTEM:SYSTEM "stumpwm-tests"> :REQUIRES "fiasco")
4: (ASDF/FIND-COMPONENT:RESOLVE-DEPENDENCY-NAME #<ASDF/SYSTEM:SYSTEM "stumpwm-tests"> "fiasco" NIL)
5: (ASDF/PLAN:MAP-DIRECT-DEPENDENCIES #<ASDF/LISP-ACTION:PREPARE-OP > #<ASDF/SYSTEM:SYSTEM "stumpwm-tests"> #<FUNCTION (LAMBDA (ASDF/PLAN::O ASDF/PLAN::C) :IN ASDF/PLAN:TRAVERSE-ACTION) {1004454CAB}>)
6: ((LAMBDA NIL :IN ASDF/PLAN:TRAVERSE-ACTION))
7: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
8: (ASDF/PLAN:TRAVERSE-ACTION #<ASDF/PLAN:SEQUENTIAL-PLAN {1004454333}> #<ASDF/LISP-ACTION:PREPARE-OP > #<ASDF/SYSTEM:SYSTEM "stumpwm-tests"> T)
9: (ASDF/PLAN:MAP-DIRECT-DEPENDENCIES #<ASDF/LISP-ACTION:PREPARE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "stumpwm-tests" "package"> #<FUNCTION (LAMBDA (ASDF/PLAN::O ASDF/PLAN::C) :IN ASDF/PLAN:TRAVERSE-ACTION) {10044548FB}>)
10: ((LAMBDA NIL :IN ASDF/PLAN:TRAVERSE-ACTION))
11: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
12: (ASDF/PLAN:TRAVERSE-ACTION #<ASDF/PLAN:SEQUENTIAL-PLAN {1004454333}> #<ASDF/LISP-ACTION:PREPARE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "stumpwm-tests" "package"> T)
13: (ASDF/PLAN:MAP-DIRECT-DEPENDENCIES #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "stumpwm-tests" "package"> #<FUNCTION (LAMBDA (ASDF/PLAN::O ASDF/PLAN::C) :IN ASDF/PLAN:TRAVERSE-ACTION) {100445477B}>)
14: ((LAMBDA NIL :IN ASDF/PLAN:TRAVERSE-ACTION))
15: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
16: (ASDF/PLAN:TRAVERSE-ACTION #<ASDF/PLAN:SEQUENTIAL-PLAN {1004454333}> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "stumpwm-tests" "package"> T)
17: (ASDF/PLAN:MAP-DIRECT-DEPENDENCIES #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "stumpwm-tests"> #<FUNCTION (LAMBDA (ASDF/PLAN::O ASDF/PLAN::C) :IN ASDF/PLAN:TRAVERSE-ACTION) {100445443B}>)
18: ((LAMBDA NIL :IN ASDF/PLAN:TRAVERSE-ACTION))
19: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
20: (ASDF/PLAN:TRAVERSE-ACTION #<ASDF/PLAN:SEQUENTIAL-PLAN {1004454333}> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "stumpwm-tests"> T)
21: ((LAMBDA NIL :IN ASDF/PLAN:MAKE-PLAN))
22: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "stumpwm-tests"> :PLAN-CLASS NIL :PLAN-OPTIONS NIL) [fast-method]
23: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "stumpwm-tests">)
24: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
25: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "stumpwm-tests">) [fast-method]
26: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP :STUMPWM-TESTS)
27: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
28: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP :STUMPWM-TESTS) [fast-method]
29: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {1004026B4B}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
30: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
31: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {1003F762DB}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
32: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP :STUMPWM-TESTS) [fast-method]
33: (ASDF/OPERATE:LOAD-SYSTEM :STUMPWM-TESTS)
34: (SB-INT:SIMPLE-EVAL-IN-LEXENV (ASDF/OPERATE:LOAD-SYSTEM :STUMPWM-TESTS) #<NULL-LEXENV>)
35: (SB-INT:SIMPLE-EVAL-IN-LEXENV (PROGN (LOAD "load-stumpwm.lisp") (ASDF/OPERATE:LOAD-SYSTEM :STUMPWM-TESTS)) #<NULL-LEXENV>)
36: (EVAL (PROGN (LOAD "load-stumpwm.lisp") (ASDF/OPERATE:LOAD-SYSTEM :STUMPWM-TESTS)))
37: (SB-IMPL::PROCESS-EVAL/LOAD-OPTIONS ((:EVAL . "(setf sb-impl::*default-external-format* :UTF-8)") (:EVAL . "(progn (load \"load-stumpwm.lisp\") (asdf:load-system :stumpwm-tests))") (:EVAL . "(if (fiasco:all-tests) (uiop:quit 0) (uiop:quit 1))") (:QUIT)))
38: (SB-IMPL::TOPLEVEL-INIT)
39: ((FLET SB-UNIX::BODY :IN SB-IMPL::START-LISP))
40: ((FLET "WITHOUT-INTERRUPTS-BODY-3" :IN SB-IMPL::START-LISP))
41: (SB-IMPL::%START-LISP)

unhandled condition in --disable-debugger mode, quitting
make: *** [Makefile:31: test] Error 1
 * ERROR: x11-wm/stumpwm-22.05_p20220818::gentoo failed (test phase):
 *   Make test failed. See above for details.
 * 
 * Call stack:
 *            ebuild.sh, line  136:  Called src_test
 *          environment, line 2549:  Called default
 *   phase-functions.sh, line  872:  Called default_src_test
 *   phase-functions.sh, line  901:  Called __eapi0_src_test
 *     phase-helpers.sh, line  836:  Called die
 * The specific snippet of code:
 *   		${emake_cmd} ${internal_opts} test || \
 *   			die "Make test failed. See above for details."
 * 
 * If you need support, post the output of `emerge --info '=x11-wm/stumpwm-22.05_p20220818::gentoo'`,
 * the complete build log and the output of `emerge -pqv '=x11-wm/stumpwm-22.05_p20220818::gentoo'`.
 * The complete build log is located at '/var/log/portage/x11-wm:stumpwm-22.05_p20220818:20221226-043653.log'.
 * For convenience, a symlink to the build log is located at '/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/temp/build.log'.
 * The ebuild environment file is located at '/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/temp/environment'.
 * Working directory: '/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2'
 * S: '/var/tmp/portage/x11-wm/stumpwm-22.05_p20220818/work/stumpwm-740e945d742d85aef36e0ed9467de9bbbf5eafd2'