==> Synchronizing chroot copy [/home/leming/armv8/root] -> [leming]...done
==> Making package: stumpwm 24.11-16 (Fri Aug 28 21:46:01 2026)
==> Retrieving sources...
  -> Updating stumpwm git repo...
  -> Found stumpwm.desktop
==> WARNING: Skipping verification of source file PGP signatures.
==> Validating source files with sha512sums...
    stumpwm ... Passed
    stumpwm.desktop ... Passed
==> Validating source files with b2sums...
    stumpwm ... Passed
    stumpwm.desktop ... Passed
==> Making package: stumpwm 24.11-16 (Sat Aug 29 03:46:05 2026)
==> Checking runtime dependencies...
==> Installing missing dependencies...
resolving dependencies...
looking for conflicting packages...

Packages (48) cl-unicode-0.1.6.r12.g07e7ff5-1  default-cursors-3-1  freetype2-2.14.3-1  libdrm-2.4.134-1  libedit-20260512_3.1-1  libepoxy-1.5.10-3  libevdev-1.13.7-1  libfontenc-1.1.9-1  libglvnd-1.7.0-3  libgudev-238-3  libinput-1.31.3-1  libpciaccess-0.19-1  libpng-1.6.58-2  libunwind-1.8.2-1  libwacom-2.19.1-1  libx11-1.8.13-1  libxau-1.0.12-1  libxcb-1.17.0-1  libxcvt-0.1.3-1  libxdmcp-1.1.5-2  libxext-1.3.7-1  libxfont2-2.0.9-1  libxkbfile-1.2.0-1  libxrandr-1.5.5-1  libxrender-0.9.12-1  libxshmfence-1.3.3-1  libxxf86vm-1.1.7-1  llvm-libs-22.1.8-2  lm_sensors-1:3.6.2-1  lua54-5.4.9-1  mesa-1:26.2.1-1  mtdev-1.1.7-1  pixman-0.46.4-1.1  spirv-tools-1:1.4.357.0-1  wayland-1.26.0-1  xcb-proto-1.17.0-4  xf86-input-libinput-1.5.0-1  xkeyboard-config-2.48-1  xorg-fonts-encodings-1.1.0-2  xorg-server-21.1.24-1  xorg-server-common-21.1.24-1  xorg-setxkbmap-1.3.5-1  xorg-xkbcomp-1.5.0-1  xorgproto-2025.1-1  cl-alexandria-1.4.r37.g390a096-1  cl-clx-0.7.8-1  cl-ppcre-2.1.2-1  sbcl-2.6.8-1

Total Download Size:    17.43 MiB
Total Installed Size:  377.66 MiB

:: Proceed with installation? [Y/n] 
:: Retrieving packages...
 sbcl-2.6.8-1-aarch64 downloading...
 cl-unicode-0.1.6.r12.g07e7ff5-1-any downloading...
 xorg-server-21.1.24-1-aarch64 downloading...
 xorg-fonts-encodings-1.1.0-2-any downloading...
 cl-clx-0.7.8-1-any downloading...
 cl-ppcre-2.1.2-1-any downloading...
 libxfont2-2.0.9-1-aarch64 downloading...
 xorg-xkbcomp-1.5.0-1-aarch64 downloading...
 cl-alexandria-1.4.r37.g390a096-1-any downloading...
 xf86-input-libinput-1.5.0-1-aarch64 downloading...
 xorg-server-common-21.1.24-1-aarch64 downloading...
 libfontenc-1.1.9-1-aarch64 downloading...
 xorg-setxkbmap-1.3.5-1-aarch64 downloading...
 libxcvt-0.1.3-1-aarch64 downloading...
checking keyring...
checking package integrity...
loading package files...
checking for file conflicts...
checking available disk space...
:: Processing package changes...
installing sbcl...
installing cl-unicode...
installing cl-ppcre...
installing xcb-proto...
installing xorgproto...
installing libxdmcp...
installing libxau...
installing libxcb...
installing libx11...
installing libxext...
installing libpciaccess...
installing libdrm...
Optional dependencies for libdrm
    cairo: needed for modetest tool
installing libxshmfence...
installing libxxf86vm...
installing libedit...
installing llvm-libs...
installing lm_sensors...
Optional dependencies for lm_sensors
    rrdtool: for logging with sensord
    perl: for sensor detection and configuration convert [installed]
installing spirv-tools...
installing default-cursors...
Optional dependencies for default-cursors
    adwaita-cursors: default cursor theme
installing wayland...
installing mesa...
Optional dependencies for mesa
    opengl-man-pages: for the OpenGL API man pages
installing libglvnd...
installing libepoxy...
installing libpng...
installing freetype2...
Optional dependencies for freetype2
    harfbuzz: Improved autohinting
installing xorg-fonts-encodings...
installing libfontenc...
installing libxfont2...
installing pixman...
installing xkeyboard-config...
installing libxkbfile...
installing xorg-xkbcomp...
installing libxrender...
installing libxrandr...
installing xorg-setxkbmap...
installing xorg-server-common...
installing libunwind...
installing libevdev...
installing libgudev...
installing libwacom...
Optional dependencies for libwacom
    python-libevdev: for libwacom-show-stylus
    python-pyudev: for libwacom-show-stylus
installing lua54...
installing mtdev...
installing libinput...
Optional dependencies for libinput
    libinput-tools: debug utilities
installing xf86-input-libinput...
installing libxcvt...
installing xorg-server...
>>> xorg-server has now the ability to run without root rights with
    the help of systemd-logind. xserver will fail to run if not launched
    from the same virtual terminal as was used to log in.
    Without root rights, log files will be in ~/.local/share/xorg/ directory.

    Old behavior can be restored through Xorg.wrap config file.
    See Xorg.wrap man page (man xorg.wrap).
installing cl-clx...
installing cl-alexandria...
:: Running post-transaction hooks...
(1/5) Updating udev hardware database...
(2/5) Reloading system manager configuration...
  Skipped: Current root is not booted.
(3/5) Reloading device manager configuration...
  Skipped: Current root is not booted.
(4/5) Arming ConditionNeedsUpdate...
(5/5) Updating the info directory file...
==> Checking buildtime dependencies...
==> Installing missing dependencies...
resolving dependencies...
looking for conflicting packages...

Packages (38) aom-3.15.0-1  cairo-1.18.4-1  dav1d-1.5.4-1  fontconfig-2:2.18.3-2  gd-2.3.3-9  graphite-1:1.3.15-1  harfbuzz-14.4.0-1  l-smash-2.14.5-4  libavif-1.4.2-1  libde265-1.1.1-1  libheif-1.23.2-1  libice-1.1.2-1  libjpeg-turbo-3.2.0-2  libpaper-2.2.8-1  libsigsegv-2.15-1  libsm-1.2.6-1  libsynctex-2026.0-2  libwebp-1.6.0-2  libxaw-1.0.16-2  libxmu-1.3.1-1  libxpm-3.5.19-1  libxt-1.3.1-1  libyuv-r2921+644251f25-1  lzo-2.10-5  openh264-2.6.0-2  perl-error-0.17030-3  perl-mailtools-2.22-3  perl-timedate-2.35-1  potrace-1.16-5  rav1e-0.8.1-3  texlive-basic-2026.1-1  x264-3:0.165.r3222.b35605a-2  x265-4.3-1  zlib-ng-2.3.3-1  zziplib-0.13.80-1  git-2.55.0-1  texlive-bin-2026.0-2  texlive-plaingeneric-2026.1-1

Total Download Size:    20.16 MiB
Total Installed Size:  223.36 MiB

:: Proceed with installation? [Y/n] 
:: Retrieving packages...
 texlive-bin-2026.0-2-aarch64 downloading...
 texlive-basic-2026.1-1-any downloading...
 texlive-plaingeneric-2026.1-1-any downloading...
 zziplib-0.13.80-1-aarch64 downloading...
 libsynctex-2026.0-2-aarch64 downloading...
 libsigsegv-2.15-1-aarch64 downloading...
checking keyring...
checking package integrity...
loading package files...
checking for file conflicts...
checking available disk space...
:: Processing package changes...
installing perl-error...
installing perl-timedate...
installing perl-mailtools...
installing zlib-ng...
installing git...
Optional dependencies for git
    git-zsh-completion: upstream zsh completion
    tk: gitk and git gui
    openssh: ssh transport and crypto
    man: show help with `git command --help`
    perl-libwww: git svn
    perl-term-readkey: git svn and interactive.singlekey setting
    perl-io-socket-ssl: git send-email TLS support
    perl-authen-sasl: git send-email TLS support
    perl-cgi: gitweb (web interface) support
    python: git svn & git p4 [installed]
    subversion: git svn
    org.freedesktop.secrets: keyring credential helper
    libsecret: libsecret credential helper [installed]
    less: the default pager for git
installing fontconfig...
Creating fontconfig configuration...
Rebuilding fontconfig cache...
installing lzo...
installing cairo...
installing libice...
installing libsm...
installing libxt...
installing libxpm...
installing libwebp...
Optional dependencies for libwebp
    libwebp-utils: WebP conversion and inspection tools
installing aom...
installing dav1d...
Optional dependencies for dav1d
    dav1d-doc: HTML documentation
installing libjpeg-turbo...
installing libyuv...
installing rav1e...
installing libavif...
installing libde265...
Optional dependencies for libde265
    sdl2-compat: for the decoder tool
installing openh264...
installing l-smash...
installing x264...
installing x265...
installing libheif...
Optional dependencies for libheif
    libjpeg-turbo: for heif-dec and heif-enc [installed]
    libpng: for heif-dec and heif-enc [installed]
    libtiff: for heif-dec and heif-enc
    dav1d: dav1d encoder [installed]
    ffmpeg: hardware decode
    openjpeg2: JPEG2000 decoder
    rav1e: rav1e encoder [installed]
installing gd...
Optional dependencies for gd
    perl: bdftogd script [installed]
installing graphite...
Optional dependencies for graphite
    graphite-docs: Documentation
installing harfbuzz...
Optional dependencies for harfbuzz
    harfbuzz-utils: utilities
installing libpaper...
installing libsigsegv...
installing libsynctex...
installing libxmu...
installing libxaw...
installing potrace...
installing zziplib...
installing texlive-bin...
Optional dependencies for texlive-bin
    psutils: to manipulate the output of dvips
installing texlive-basic...
Optional dependencies for texlive-basic
    perl-tk: for the tlmgr GUI
    biber: for bibliography processing
installing texlive-plaingeneric...
:: Running post-transaction hooks...
(1/8) Creating system user accounts...
Creating group 'git' with GID 967.
Creating user 'git' (git daemon user) with UID 967 and GID 967.
(2/8) Reloading system manager configuration...
  Skipped: Current root is not booted.
(3/8) Arming ConditionNeedsUpdate...
(4/8) Updating fontconfig configuration...
(5/8) Updating TeXLive filename database...
mktexlsr: Updating /etc/texmf/ls-R... 
mktexlsr: Updating /usr/share/texmf-dist/ls-R... 
mktexlsr: Updating /var/lib/texmf/ls-R... 
mktexlsr: Done.
(6/8) Updating TeXLive format files...
(7/8) Updating TeXLive font maps...
mktexlsr: Updating /etc/texmf/ls-R... 
mktexlsr: Updating /usr/share/texmf-dist/ls-R... 
mktexlsr: Updating /var/lib/texmf/ls-R... 
mktexlsr: Done.
(8/8) Updating fontconfig cache...
==> Retrieving sources...
  -> Found stumpwm.desktop
==> WARNING: Skipping all source file integrity checks.
==> Extracting sources...
  -> Creating working copy of stumpwm git repo...
Cloning into 'stumpwm'...
done.
Switched to a new branch 'makepkg'
==> Starting prepare()...
Auto-merging make-image.lisp.in
==> Starting pkgver()...
==> Starting build()...
checking for sbcl... /usr/bin/sbcl
configure: WARNING: SBCL_HOME must be defined to use asdf/quicklisp (it should be where your sbcl.core resides)
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 "(require 'asdf)" --eval "(setf sb-impl::*default-external-format* :UTF-8)" --load ./make-image.lisp
This is SBCL 2.6.8, 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 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-1/package-tmpGHU3ALSV.fasl
; compilation finished in 0:00:00.007
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/definitions.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-1/definitions-tmpAAURSO1.fasl
; compilation finished in 0:00:00.017
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:DEFINE-CONSTANT in DEFMACRO
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/binding.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-1/binding-tmp5GEXGEG5.fasl
; compilation finished in 0:00:00.024
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:IF-LET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:WHEN-LET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:WHEN-LET* in DEFMACRO
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/strings.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/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 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-1/conditions-tmpJAIDFZTC.fasl
; compilation finished in 0:00:00.029
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:IGNORE-SOME-CONDITIONS in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:UNWIND-PROTECT-CASE in DEFMACRO
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/symbols.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-1/symbols-tmp8V3J6PE9.fasl
; compilation finished in 0:00:00.022
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/macros.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-1/macros-tmp9V47YWQF.fasl
; compilation finished in 0:00:00.159
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:WITH-GENSYMS in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:WITH-UNIQUE-NAMES in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:ONCE-ONLY in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:DESTRUCTURING-CASE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:DESTRUCTURING-CCASE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:DESTRUCTURING-ECASE in DEFMACRO
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/functions.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-1/functions-tmp9BN22RMA.fasl
; compilation finished in 0:00:00.074
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA::ENSURE-FUNCTIONF/1 in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:ENSURE-FUNCTIONF in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:NAMED-LAMBDA in DEFMACRO
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/lists.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-1/lists-tmp1CXFJSK9.fasl
; compilation finished in 0:00:00.195
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:DOPLIST in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:APPENDF in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:NCONCF in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:UNIONF in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:NUNIONF in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:REVERSEF in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:NREVERSEF in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:REMOVE-FROM-PLISTF in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:DELETE-FROM-PLISTF in DEFMACRO
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/types.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-1/types-tmpX4BRKI0R.fasl
; compilation finished in 0:00:00.119
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:COERCEF in DEFMACRO
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/io.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-1/io-tmpQ371UGST.fasl
; compilation finished in 0:00:00.277
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA::WITH-OPEN-FILE* in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:WITH-INPUT-FROM-FILE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:WITH-OUTPUT-TO-FILE in DEFMACRO
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/hash-tables.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-1/hash-tables-tmp2OWI3Q7U.fasl
; compilation finished in 0:00:00.091
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:ENSURE-GETHASH in DEFMACRO
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/control-flow.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-1/control-flow-tmp9KKTJMYV.fasl
; compilation finished in 0:00:00.070
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:SWITCH in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:ESWITCH in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:CSWITCH in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:WHICHEVER in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:XOR in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:NTH-VALUE-OR in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:MULTIPLE-VALUE-PROG2 in DEFMACRO
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/arrays.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-1/arrays-tmpJU0JWO19.fasl
; compilation finished in 0:00:00.028
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/sequences.lisp" (written 07 MAR 2026 03:17:12 AM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

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


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-1/sequences-tmpZX2WN8N4.fasl
; compilation finished in 0:00:00.383
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:REMOVEF in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:DELETEF in DEFMACRO
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/numbers.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-1/numbers-tmpOU81XRV0.fasl
; compilation finished in 0:00:00.267
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:MAXF in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA:MINF in DEFMACRO
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-1/features.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-1/features-tmpY2ML9CFA.fasl
; compilation finished in 0:00:00.011
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-2/package.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-2/package-tmpX2JYJDQE.fasl
; compilation finished in 0:00:00.010
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-2/arrays.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-2/arrays-tmpOPCILR65.fasl
; compilation finished in 0:00:00.024
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-2/control-flow.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-2/control-flow-tmpRV9F8A9A.fasl
; compilation finished in 0:00:00.011
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA-2:LINE-UP-FIRST in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining ALEXANDRIA-2:LINE-UP-LAST in DEFMACRO
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-2/sequences.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-2/sequences-tmpK2ZAJT4I.fasl
; compilation finished in 0:00:00.005
; compiling file "/usr/share/common-lisp/source/alexandria/alexandria-2/lists.lisp" (written 07 MAR 2026 03:17:12 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/alexandria/alexandria-2/lists-tmpUX5S4ADN.fasl
; compilation finished in 0:00:00.005
; compiling file "/usr/share/common-lisp/source/cl-ppcre/packages.lisp" (written 25 APR 2026 05:54:40 PM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/cl-ppcre/packages-tmp10401X32.fasl
; compilation finished in 0:00:00.004
; compiling file "/usr/share/common-lisp/source/cl-ppcre/specials.lisp" (written 25 APR 2026 05:54:40 PM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/cl-ppcre/specials-tmpZ7CBRM0G.fasl
; compilation finished in 0:00:00.017
; compiling file "/usr/share/common-lisp/source/cl-ppcre/util.lisp" (written 25 APR 2026 05:54:40 PM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a STRING, not a (OR NULL
                                                                   (SIMPLE-ARRAY
                                                                    * (*))).

; 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 (OR NULL (SIMPLE-ARRAY * (*))).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a STRING, not a (OR
                                                                SIMPLE-BASE-STRING
                                                                NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a STRING, not a (OR SIMPLE-BASE-STRING NULL).
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        TEST-FUNCTION is not known to be a function

; 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 /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/cl-ppcre/util-tmp9OZEQ0G2.fasl
; compilation finished in 0:00:00.079
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::DEFCONSTANT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::WITH-UNIQUE-NAMES in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::WITH-REBINDING in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::MAYBE-COERCE-TO-SIMPLE-STRING in DEFMACRO
; compiling file "/usr/share/common-lisp/source/cl-ppcre/errors.lisp" (written 25 APR 2026 05:54:40 PM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/cl-ppcre/errors-tmpB2JTL1W9.fasl
; compilation finished in 0:00:00.042
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::SIGNAL-SYNTAX-ERROR* in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::SIGNAL-SYNTAX-ERROR in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::SIGNAL-INVOCATION-ERROR in DEFMACRO
; compiling file "/usr/share/common-lisp/source/cl-ppcre/charset.lisp" (written 25 APR 2026 05:54:40 PM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; file: /usr/share/common-lisp/source/cl-ppcre/charset.lisp
; in: DEFUN MIX
;     (+ CL-PPCRE::CODE CL-PPCRE::HASH)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
      unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a NUMBER, not a FIXNUM.
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a NUMBER, not a FIXNUM.
      etc.

;     (LOGAND MOST-POSITIVE-FIXNUM (+ CL-PPCRE::CODE CL-PPCRE::HASH))
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

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

;     (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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR FLOAT
                                                    (RATIONAL (-35184372088830)
                                                              (35184372088830))), not a RATIONAL.

;     (1+ (MOD CL-PPCRE::HASH (1- (LENGTH VECTOR))))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL (-35184372088830)
;                                         (35184372088830))), not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a (OR FLOAT
                                  (RATIONAL (-35184372088830) (35184372088830))), not a FIXNUM.
      The result is a (VALUES
                       (OR FLOAT (RATIONAL (-35184372088829) (35184372088831)))
                       &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (OR FLOAT
                                  (RATIONAL (-35184372088830) (35184372088830))), not a (UNSIGNED-BYTE
                                                                                         64).
      The result is a (VALUES
                       (OR FLOAT (RATIONAL (-35184372088829) (35184372088831)))
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR FLOAT
;                                   (RATIONAL (-35184372088830) (35184372088830))), not a FIXNUM.
;       The result is a (VALUES
;                        (OR FLOAT (RATIONAL (-35184372088829) (35184372088831)))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (OR FLOAT
;                                   (RATIONAL (-35184372088830) (35184372088830))), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The result is a (VALUES
;                        (OR FLOAT (RATIONAL (-35184372088829) (35184372088831)))
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do <-INTEGER-FIXNUM (cost 10)
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a INTEGER, not a FIXNUM.

; in: DEFUN %ADD-TO-CHARSET/EXPAND
;     (>= CL-PPCRE::NEW-SIZE 371370)
; 
; note: forced to do <-INTEGER-FIXNUM (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline ASH (cost 1) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a (VALUES (OR (INTEGER * -2) (INTEGER 0 0) (INTEGER 2))
                              &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline ASH (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a (VALUES (OR (INTEGER * -2) (INTEGER 0 0) (INTEGER 2))
                              &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      etc.

;     (* 2 CL-PPCRE::NEW-SIZE)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -2) (INTEGER 0 0) (INTEGER 2))
;                               &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -2) (INTEGER 0 0) (INTEGER 2))
;                               &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER * 4611686018427387903), not a (UNSIGNED-BYTE
                                                                      64).
      The result is a (VALUES (INTEGER * 4611686018427387902) &OPTIONAL), not a (VALUES
                                                                                 (UNSIGNED-BYTE
                                                                                  64)
                                                                                 &OPTIONAL).
      etc.

; in: DEFUN MAP-CHARSET
;     (DECF CL-PPCRE::N)
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER * 4611686018427387903), not a (UNSIGNED-BYTE
;                                                                       64).
;       The result is a (VALUES (INTEGER * 4611686018427387902) &OPTIONAL), not a (VALUES
;                                                                                  (UNSIGNED-BYTE
;                                                                                   64)
;                                                                                  &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a SINGLE-FLOAT.
                        The second argument is a REAL, not a RATIONAL.

; in: DEFUN CREATE-CHARSET-FROM-TEST-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 
; ==>
;   (>= CL-PPCRE::CODE #:LIM0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
                        The second argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-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 CHAR)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function
SIMPLE-COMPILER-NOTE: forced to do full call
      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.

;     (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 
; ==>
;   (>= CL-PPCRE::CODE #:LIM0)
; 
; note: forced to do full call
;       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.


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/cl-ppcre/charset-tmpP3BI68WQ.fasl
; compilation finished in 0:00:00.094
; compiling file "/usr/share/common-lisp/source/cl-ppcre/charmap.lisp" (written 25 APR 2026 05:54:40 PM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        TEST-FUNCTION is not known to be a function

; 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
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a SINGLE-FLOAT.
                        The second argument is a REAL, not a RATIONAL.

; in: DEFUN CREATE-CHARMAP-FROM-TEST-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 
; ==>
;   (>= CL-PPCRE::CODE #:LIM0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
                        The second argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a RATIONAL.

;     (1- CL-PPCRE::END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a SINGLE-FLOAT.
                        The second argument is a REAL, not a RATIONAL.

;     (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 #:LIM31)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
                        The second argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-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 CHAR)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function
SIMPLE-COMPILER-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
SIMPLE-COMPILER-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
SIMPLE-COMPILER-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
SIMPLE-COMPILER-NOTE: forced to do full call
      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.

;     (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 
; ==>
;   (>= CL-PPCRE::CODE #:LIM0)
; 
; note: forced to do full call
;       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.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a REAL, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
                                                             &OPTIONAL).
      etc.

;     (1- CL-PPCRE::END)
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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.

;     (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 #:LIM31)
; 
; note: forced to do full call
;       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 /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/cl-ppcre/charmap-tmpQDARA81Z.fasl
; compilation finished in 0:00:00.107
; compiling file "/usr/share/common-lisp/source/cl-ppcre/chartest.lisp" (written 25 APR 2026 05:54:40 PM):
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a SINGLE-FLOAT.
                        The second argument is a REAL, not a RATIONAL.

; file: /usr/share/common-lisp/source/cl-ppcre/chartest.lisp
; in: DEFUN CREATE-HASH-TABLE-FROM-TEST-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 
; ==>
;   (>= CL-PPCRE::CODE #:LIM0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
                        The second argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-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 CHAR)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function
SIMPLE-COMPILER-NOTE: forced to do full call
      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.

;     (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 
; ==>
;   (>= CL-PPCRE::CODE #:LIM0)
; 
; note: forced to do full call
;       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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; in: DEFUN CREATE-OPTIMIZED-TEST-FUNCTION
;     (- CL-PPCRE::END CL-PPCRE::START)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, 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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
SIMPLE-COMPILER-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 division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

;     (- CL-PPCRE::END CL-PPCRE::START)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, 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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
SIMPLE-COMPILER-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 division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &OPTIONAL).
      etc.

;     (- CL-PPCRE::END CL-PPCRE::START)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do >-FIXNUM-INTEGER (cost 10)
      unable to do inline fixnum comparison (cost 4) because:
      The second argument is a INTEGER, not a FIXNUM.

;     (<= (CL-PPCRE::CHARSET-COUNT CL-PPCRE::CHARSET)
;         (CEILING (- CL-PPCRE::END CL-PPCRE::START) 2))
; 
; note: forced to do >-FIXNUM-INTEGER (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a INTEGER, not a FIXNUM.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &OPTIONAL).
      etc.

;     (- CL-PPCRE::END CL-PPCRE::START)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do >-FIXNUM-INTEGER (cost 10)
      unable to do inline fixnum comparison (cost 4) because:
      The second argument is a INTEGER, not a FIXNUM.

;     (<= (HASH-TABLE-COUNT HASH-TABLE)
;         (CEILING (- CL-PPCRE::END CL-PPCRE::START) 2))
; 
; note: forced to do >-FIXNUM-INTEGER (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a INTEGER, not a FIXNUM.


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/cl-ppcre/chartest-tmpYEMMM7SE.fasl
; compilation finished in 0:00:00.062
; compiling file "/usr/share/common-lisp/source/cl-ppcre/lexer.lisp" (written 25 APR 2026 05:54:40 PM):
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20)

; file: /usr/share/common-lisp/source/cl-ppcre/lexer.lisp
; in: DEFUN NEXT-CHAR
;     (CL-PPCRE::SIGNAL-SYNTAX-ERROR* CL-PPCRE::ERROR-POS
;                                     "Comment group not closed.")
; 
; note: doing signed word to integer coercion (cost 20)
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20)

; in: DEFUN GET-NUMBER
;     (IF (< CL-PPCRE::END-POS CL-PPCRE::LEXER-LEN)
;         CL-PPCRE::END-POS
;         CL-PPCRE::LEXER-LEN)
; 
; note: doing signed word to integer coercion (cost 20)
CODE-DELETION-NOTE: deleting unreachable code
CODE-DELETION-NOTE: deleting unreachable code

; in: DEFUN MAKE-CHAR-FROM-CODE
;     (CL-PPCRE::SIGNAL-SYNTAX-ERROR* CL-PPCRE::ERROR-POS
;                                     "No character for hex-code ~X." NUMBER)
; 
; note: deleting unreachable code
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first argument is a CHARACTER, not a BASE-CHAR.

; 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 /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/cl-ppcre/lexer-tmp73HU0RPK.fasl
; compilation finished in 0:00:00.590
; compiling file "/usr/share/common-lisp/source/cl-ppcre/parser.lisp" (written 25 APR 2026 05:54:40 PM):
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20)

; file: /usr/share/common-lisp/source/cl-ppcre/parser.lisp
; in: DEFUN GROUP
;     (CL-PPCRE::SIGNAL-SYNTAX-ERROR* (+ CL-PPCRE::OPEN-PAREN-POS 2)
;                                     "Opening paren has no matching closing paren.")
; 
; note: doing signed word to integer coercion (cost 20)
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      because:
                        Upgraded element type of array is not known at compile time.

; in: DEFUN SEQ
;     (VECTOR-PUSH-EXTEND CL-PPCRE::QUANT (CAR CL-PPCRE::LAST-CDR))
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/cl-ppcre/parser-tmpIO5N7K88.fasl
; compilation finished in 0:00:00.080
; compiling file "/usr/share/common-lisp/source/cl-ppcre/regex-class.lisp" (written 25 APR 2026 05:54:40 PM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR LIST
                                                    (AND VECTOR
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           BASE-CHAR))
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           CHARACTER)))
                                                    SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; 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 VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                    (NOT (SIMPLE-ARRAY CHARACTER)))
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          NULL
                                                                                          (SIMPLE-ARRAY
                                                                                           *
                                                                                           (*))).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR NULL
;                                                                        (SIMPLE-ARRAY
;                                                                         * (*))).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          SIMPLE-BASE-STRING
                                                                                          NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
;                                                                     SIMPLE-BASE-STRING
;                                                                     NULL).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

;     (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 /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/cl-ppcre/regex-class-tmpCM21U60Z.fasl
; compilation finished in 0:00:00.052
; compiling file "/usr/share/common-lisp/source/cl-ppcre/regex-class-util.lisp" (written 25 APR 2026 05:54:40 PM):
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a SINGLE-FLOAT.

; 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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               SINGLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               DOUBLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        The operands might not be the same type.
; 
; note: unable to open code because: The operands might not be the same type.
SIMPLE-COMPILER-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 (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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a 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.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a SINGLE-FLOAT.

; 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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               SINGLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               DOUBLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        The operands might not be the same type.
; 
; note: unable to open code because: The operands might not be the same type.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a (OR COMPLEX
                                                    (REAL 1
                                                     1)), not a SINGLE-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 COMPLEX (REAL 1 1)), not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a (OR COMPLEX
                                                    (REAL 1
                                                     1)), not a DOUBLE-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 COMPLEX (REAL 1 1)), not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a (OR COMPLEX
                                                    (REAL 1 1)), not a (COMPLEX
                                                                        SINGLE-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 COMPLEX (REAL 1 1)), not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a (OR COMPLEX
                                                    (REAL 1 1)), not a (COMPLEX
                                                                        DOUBLE-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 COMPLEX (REAL 1 1)), not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        The operands might not be the same type.
; 
; note: unable to open code because: The operands might not be the same type.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline float comparison (cost 3) because:
      The first argument is a (OR COMPLEX (REAL 1 1)), not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a SINGLE-FLOAT.
      unable to do inline float comparison (cost 3) because:
      The first argument is a (OR COMPLEX (REAL 1 1)), not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR COMPLEX (REAL 1 1)), not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR COMPLEX (REAL 1 1)), not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; 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 
; ==>
;   (+ #:SUM6 CL-PPCRE::LEN)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a NUMBER, not a FIXNUM.
      The second argument is a (NOT NULL), not a FIXNUM.
      The result is a (VALUES NUMBER &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 (NOT NULL), not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES NUMBER &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 (NOT NULL), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a SINGLE-FLOAT.
                        The second argument is a NUMBER, not a RATIONAL.

; in: DEFMETHOD REGEX-LENGTH (ALTERNATION)
;     (/= CL-PPCRE::LEN CL-PPCRE::OLD-LEN)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a DOUBLE-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 DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               SINGLE-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 (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               DOUBLE-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 (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        The operands might not be the same type.
; 
; note: unable to open code because: The operands might not be the same type.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline float comparison (cost 3) because:
      The first argument is a (NOT NULL), not a SINGLE-FLOAT.
      The second argument is a (NOT NULL), not a SINGLE-FLOAT.
      unable to do inline float comparison (cost 3) because:
      The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
      The second argument is a (NOT NULL), not a DOUBLE-FLOAT.
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (NOT NULL), not a SINGLE-FLOAT.
;       The second argument is a (NOT NULL), not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
;       The second argument is a (NOT NULL), not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (NOT NULL), not a SINGLE-FLOAT.
                        The second argument is a T, not a SINGLE-FLOAT.

; in: DEFMETHOD REGEX-LENGTH (BRANCH)
;     (EQL CL-PPCRE::THEN-LENGTH
;          (CL-PPCRE::REGEX-LENGTH (CL-PPCRE::ELSE-REGEX CL-PPCRE::BRANCH)))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (NOT NULL), not a SINGLE-FLOAT.
;   The second argument is a T, not a SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
                        The second argument is a T, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
;   The second argument is a T, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
      The second argument is a T, not a (UNSIGNED-BYTE 64).
      unable to do inline (signed-byte 64) comparison (cost 6) because:
      The first argument is a (NOT NULL), not a (SIGNED-BYTE 64).
      The second argument is a T, not a (SIGNED-BYTE 64).
; 
; note: forced to do full call
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       unable to do inline (signed-byte 64) comparison (cost 6) because:
;       The first argument is a (NOT NULL), not a (SIGNED-BYTE 64).
;       The second argument is a T, not a (SIGNED-BYTE 64).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a SINGLE-FLOAT.
                        The second argument is a T, not a SINGLE-FLOAT.

; in: DEFMETHOD REGEX-LENGTH (REPETITION)
;     (EQL CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a SINGLE-FLOAT.
;   The second argument is a T, not a SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a DOUBLE-FLOAT.
                        The second argument is a T, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a DOUBLE-FLOAT.
;   The second argument is a T, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The second argument is a T, not a (UNSIGNED-BYTE 64).
      unable to do inline (signed-byte 64) comparison (cost 6) because:
      The first argument is a T, not a (SIGNED-BYTE 64).
      The second argument is a T, not a (SIGNED-BYTE 64).
; 
; note: forced to do full call
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       unable to do inline (signed-byte 64) comparison (cost 6) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The second argument is a T, not a (SIGNED-BYTE 64).
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The second argument is a T, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

;     (* CL-PPCRE::MINIMUM CL-PPCRE::LEN)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; 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 
; ==>
;   (+ #:SUM6 CL-PPCRE::LEN)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a NUMBER, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &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 T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &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 T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a SINGLE-FLOAT.
                        The second argument is a REAL, not a RATIONAL.

; 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 
; ==>
;   (< #:MINMAXTMP10 #:MINMAX9)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
                        The second argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      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 full call
;       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.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a SINGLE-FLOAT.
                        The second argument is a REAL, not a RATIONAL.

; 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 to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
                        The second argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline float comparison (cost 3) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      unable to do inline float comparison (cost 3) because:
      The first argument is a T, not a DOUBLE-FLOAT.
      The second argument is a T, not a DOUBLE-FLOAT.
      etc.
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The second argument is a T, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

; in: DEFMETHOD REGEX-MIN-LENGTH (REPETITION)
;     (* (CL-PPCRE::MINIMUM CL-PPCRE::REPETITION)
;        (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION))
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a SINGLE-FLOAT.
                        The second argument is a NUMBER, not a RATIONAL.

; in: DEFMETHOD COMPUTE-OFFSETS (ALTERNATION T)
;     (/= CL-PPCRE::CURR-OFFSET CL-PPCRE::OLD-OFFSET)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a DOUBLE-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 DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               SINGLE-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 (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               DOUBLE-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 (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        The operands might not be the same type.
; 
; note: unable to open code because: The operands might not be the same type.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline float comparison (cost 3) because:
      The first argument is a (NOT NULL), not a SINGLE-FLOAT.
      The second argument is a (NOT NULL), not a SINGLE-FLOAT.
      unable to do inline float comparison (cost 3) because:
      The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
      The second argument is a (NOT NULL), not a DOUBLE-FLOAT.
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (NOT NULL), not a SINGLE-FLOAT.
;       The second argument is a (NOT NULL), not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
;       The second argument is a (NOT NULL), not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (NOT NULL), not a SINGLE-FLOAT.
                        The second argument is a T, not a SINGLE-FLOAT.

; 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: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (NOT NULL), not a SINGLE-FLOAT.
;   The second argument is a T, not a SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
                        The second argument is a T, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
;   The second argument is a T, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
      The second argument is a T, not a (UNSIGNED-BYTE 64).
      unable to do inline (signed-byte 64) comparison (cost 6) because:
      The first argument is a (NOT NULL), not a (SIGNED-BYTE 64).
      The second argument is a T, not a (SIGNED-BYTE 64).
; 
; note: forced to do full call
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       unable to do inline (signed-byte 64) comparison (cost 6) because:
;       The first argument is a (NOT NULL), not a (SIGNED-BYTE 64).
;       The second argument is a T, not a (SIGNED-BYTE 64).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; in: DEFMETHOD COMPUTE-OFFSETS (REPETITION T)
;     (+ CL-PPCRE::START-POS (* CL-PPCRE::MINIMUM CL-PPCRE::LEN))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The second argument is a T, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

;     (* CL-PPCRE::MINIMUM CL-PPCRE::LEN)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, 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 float arithmetic (cost 2) because:
      The first argument is a T, 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::START-POS (* CL-PPCRE::MINIMUM CL-PPCRE::LEN))
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, 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 float arithmetic (cost 2) because:
;       The first argument is a T, 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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.

; in: DEFMETHOD COMPUTE-OFFSETS (CHAR-CLASS T)
;     (1+ CL-PPCRE::START-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.

; in: DEFMETHOD COMPUTE-OFFSETS (EVERYTHING T)
;     (1+ CL-PPCRE::START-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; in: DEFMETHOD COMPUTE-OFFSETS (STR T)
;     (+ CL-PPCRE::START-POS (CL-PPCRE::LEN CL-PPCRE::STR))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; in: DEFMETHOD COMPUTE-OFFSETS (FILTER T)
;     (+ CL-PPCRE::START-POS CL-PPCRE::LEN)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a (NOT NULL), not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a (NOT NULL), not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a (NOT NULL), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/cl-ppcre/regex-class-util-tmp9DT7SEFG.fasl
; compilation finished in 0:00:00.401
; compiling file "/usr/share/common-lisp/source/cl-ppcre/convert.lisp" (written 25 APR 2026 05:54:40 PM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        TEST-FUNCTION is not known to be a function

; 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
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first argument is a CHARACTER, not a BASE-CHAR.

;     (CHAR-DOWNCASE CHAR)
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-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 (CHAR-UPCASE CHAR))
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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 (CHAR-DOWNCASE CHAR))
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first argument is a CHARACTER, not a BASE-CHAR.

;     (CHAR-DOWNCASE CHAR)
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-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 (CHAR-UPCASE CHAR))
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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 CHAR)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function
SIMPLE-COMPILER-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
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first argument is a CHARACTER, not a BASE-CHAR.

;     (CHAR-DOWNCASE CHAR)
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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-DOWN)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function
SIMPLE-COMPILER-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
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first argument is a CHARACTER, not a BASE-CHAR.

;     (CHAR-DOWNCASE CHAR)
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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-DOWN)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   TEST-FUNCTION is not known to be a function
SIMPLE-COMPILER-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
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20)

; in: DEFUN MAYBE-SPLIT-REPETITION
;     (- CL-PPCRE::MAXIMUM CL-PPCRE::MINIMUM)
; 
; note: doing signed word to integer coercion (cost 20)
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a (OR NULL
                                                                    (SIMPLE-ARRAY
                                                                     * (*))).
                        The second argument is a SEQUENCE, not a (OR NULL
                                                                     (SIMPLE-ARRAY
                                                                      * (*))).

; in: DEFUN MAYBE-ACCUMULATE
;     (SUBSEQ (SLOT-VALUE CL-PPCRE::STARTS-WITH 'CL-PPCRE::STR)
;             (- (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH)
;                (CL-PPCRE::LEN CL-PPCRE::STR)))
; ==>
;   (REPLACE #:SEQUENCE #:NEW2 :START1 #:START :END1 NIL)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (OR NULL (SIMPLE-ARRAY * (*))).
;   The second argument is a SEQUENCE, not a (OR NULL (SIMPLE-ARRAY * (*))).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a (OR NULL
                                                                    (SIMPLE-ARRAY
                                                                     * (*))).
                        The second argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (OR NULL (SIMPLE-ARRAY * (*))).
;   The second argument is a SEQUENCE, not a LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a (OR
                                                                 SIMPLE-BASE-STRING
                                                                 NULL).
                        The second argument is a SEQUENCE, not a (OR NULL
                                                                     (SIMPLE-ARRAY
                                                                      CHARACTER
                                                                      (*))).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (OR SIMPLE-BASE-STRING NULL).
;   The second argument is a SEQUENCE, not a (OR NULL
;                                                (SIMPLE-ARRAY CHARACTER (*))).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a (OR NULL
                                                                    (SIMPLE-ARRAY
                                                                     CHARACTER
                                                                     (*))).
                        The second argument is a SEQUENCE, not a (OR
                                                                  SIMPLE-BASE-STRING
                                                                  NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (OR NULL
;                                               (SIMPLE-ARRAY CHARACTER (*))).
;   The second argument is a SEQUENCE, not a (OR SIMPLE-BASE-STRING NULL).
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20)

;     (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH)
; --> FUNCALL 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20)
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20)

;     (SUBSEQ (SLOT-VALUE CL-PPCRE::STARTS-WITH 'CL-PPCRE::STR)
;             (- (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH)
;                (CL-PPCRE::LEN CL-PPCRE::STR)))
; ==>
;   (REPLACE #:SEQUENCE #:NEW2 :START1 #:START :END1 NIL)
; 
; note: doing signed word to integer coercion (cost 20)
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

; 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.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a SINGLE-FLOAT.

; 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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               SINGLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               DOUBLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        The operands might not be the same type.
; 
; note: unable to open code because: The operands might not be the same type.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

; 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.
SIMPLE-COMPILER-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 LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
SIMPLE-COMPILER-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 SYMBOL (NOT NULL))
                                                     CHARACTER), not a SIMPLE-BASE-STRING.

; 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 SIMPLE-BASE-STRING.
;   The second argument is a (OR STRING (AND SYMBOL (NOT NULL))
;                                CHARACTER), not a SIMPLE-BASE-STRING.
SIMPLE-COMPILER-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 SYMBOL (NOT NULL))
                                                     CHARACTER), not a (SIMPLE-ARRAY
                                                                        CHARACTER
                                                                        (*)).
; 
; 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 SYMBOL (NOT NULL))
;                                CHARACTER), not a (SIMPLE-ARRAY CHARACTER (*)).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.

;     (- CL-PPCRE::REG-NUM CL-PPCRE::REG-INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.

;     (1- CL-PPCRE::BACKREF-NUMBER)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

;     (COPY-SEQ CL-PPCRE::BACKREF-NAME)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
SIMPLE-COMPILER-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 LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, 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 5) because:
      The first argument is a T, 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
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

;     (- CL-PPCRE::REG-NUM CL-PPCRE::REG-INDEX)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, 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 5) because:
;       The first argument is a T, 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
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

;     (1- CL-PPCRE::BACKREF-NUMBER)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
                                                             (UNSIGNED-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 full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
;                                                              (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR LIST
                                                    (AND VECTOR
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           BASE-CHAR))
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           CHARACTER)))
                                                    SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; 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 VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                    (NOT (SIMPLE-ARRAY CHARACTER)))
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          NULL
                                                                                          (SIMPLE-ARRAY
                                                                                           *
                                                                                           (*))).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR NULL
;                                                                        (SIMPLE-ARRAY
;                                                                         * (*))).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          SIMPLE-BASE-STRING
                                                                                          NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
;                                                                     SIMPLE-BASE-STRING
;                                                                     NULL).


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/cl-ppcre/convert-tmp8065ESJT.fasl
; compilation finished in 0:00:00.423
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::CASE-INSENSITIVE-MODE-P in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::MULTI-LINE-MODE-P in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::SINGLE-LINE-MODE-P in DEFMACRO
; compiling file "/usr/share/common-lisp/source/cl-ppcre/optimize.lisp" (written 25 APR 2026 05:54:40 PM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a VECTOR, not a (OR NULL
                                                                   (SIMPLE-ARRAY
                                                                    * (*))).

; 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 VECTOR, not a (OR NULL (SIMPLE-ARRAY * (*))).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a VECTOR, not a (OR
                                                                SIMPLE-BASE-STRING
                                                                NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a VECTOR, not a (OR SIMPLE-BASE-STRING NULL).
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a SINGLE-FLOAT.

; 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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a T, not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a SINGLE-FLOAT.

; 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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               SINGLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               DOUBLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        The operands might not be the same type.
; 
; note: unable to open code because: The operands might not be the same type.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a SINGLE-FLOAT.

; 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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               SINGLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               DOUBLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        The operands might not be the same type.
; 
; note: unable to open code because: The operands might not be the same type.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a STRING, not a SIMPLE-ARRAY.

;     (CHAR CL-PPCRE::STR CL-PPCRE::I)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a VECTOR.

;     (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 T, not a VECTOR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a SEQUENCE, not a (OR NULL
                                                                     (SIMPLE-ARRAY
                                                                      * (*))).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR NULL (SIMPLE-ARRAY * (*))).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a SEQUENCE, not a (OR
                                                                  SIMPLE-BASE-STRING
                                                                  NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR SIMPLE-BASE-STRING NULL).
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a SINGLE-FLOAT.
                        The second argument is a REAL, not a RATIONAL.

; 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 
; ==>
;   (< #:MINMAXTMP11 #:MINMAX10)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
                        The second argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      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 full call
;       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.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a SINGLE-FLOAT.
                        The second argument is a REAL, not a RATIONAL.

; 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 to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
                        The second argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline float comparison (cost 3) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      unable to do inline float comparison (cost 3) because:
      The first argument is a T, not a DOUBLE-FLOAT.
      The second argument is a T, not a DOUBLE-FLOAT.
      etc.
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; in: DEFMETHOD COMPUTE-MIN-REST (STR T)
;     (+ CL-PPCRE::CURRENT-MIN-REST (CL-PPCRE::LEN CL-PPCRE::STR))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; in: DEFMETHOD COMPUTE-MIN-REST (FILTER T)
;     (+ CL-PPCRE::CURRENT-MIN-REST (OR (CL-PPCRE::LEN CL-PPCRE::FILTER) 0))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, 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 float arithmetic (cost 2) because:
      The first argument is a T, 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.
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, 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 float arithmetic (cost 2) because:
;       The first argument is a T, 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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; in: DEFMETHOD COMPUTE-MIN-REST (REPETITION T)
;     (+ CL-PPCRE::CURRENT-MIN-REST
;        (* (CL-PPCRE::MINIMUM CL-PPCRE::REPETITION)
;           (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION)))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The second argument is a T, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

;     (* (CL-PPCRE::MINIMUM CL-PPCRE::REPETITION)
;        (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION))
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, 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 float arithmetic (cost 2) because:
      The first argument is a T, 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::CURRENT-MIN-REST
;        (* (CL-PPCRE::MINIMUM CL-PPCRE::REPETITION)
;           (CL-PPCRE::MIN-LEN CL-PPCRE::REPETITION)))
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, 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 float arithmetic (cost 2) because:
;       The first argument is a T, 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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; in: DEFMETHOD COMPUTE-MIN-REST (LOOKBEHIND T)
;     (+ CL-PPCRE::CURRENT-MIN-REST (CL-PPCRE::LEN CL-PPCRE::LOOKBEHIND))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.

; in: DEFMETHOD COMPUTE-MIN-REST (REGEX T)
;     (1+ CL-PPCRE::CURRENT-MIN-REST)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/cl-ppcre/optimize-tmp7S8Z6FGF.fasl
; compilation finished in 0:00:00.235
; compiling file "/usr/share/common-lisp/source/cl-ppcre/closures.lisp" (written 25 APR 2026 05:54:40 PM):
SIMPLE-COMPILER-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.

; 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20)

; in: DEFMETHOD CREATE-MATCHER-AUX (LOOKBEHIND T)
;     (FUNCALL CL-PPCRE::TEST-MATCHER (- CL-PPCRE::START-POS CL-PPCRE::LEN))
; 
; note: doing signed word to integer coercion (cost 20)
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20)
; 
; note: doing signed word to integer coercion (cost 20)
SIMPLE-COMPILER-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 (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
SIMPLE-COMPILER-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 (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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR VECTOR
                                                    SB-KERNEL:EXTENDED-SEQUENCE
                                                    CONS), not a VECTOR.

;     (LENGTH CL-PPCRE::END-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR VECTOR SB-KERNEL:EXTENDED-SEQUENCE
;                               CONS), not a VECTOR.
SIMPLE-COMPILER-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::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 (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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-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 (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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20)

;     (FUNCALL CL-PPCRE::NEXT-FN (+ CL-PPCRE::START-POS CL-PPCRE::LEN))
; 
; note: doing signed word to integer coercion (cost 20)
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20)
; 
; note: doing signed word to integer coercion (cost 20)
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20)
; 
; note: doing signed word to integer coercion (cost 20)
SIMPLE-COMPILER-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 (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 (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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        FN is not known to be a function

; 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
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        NEXT-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 /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/cl-ppcre/closures-tmpSIT3QPKP.fasl
; compilation finished in 0:00:00.263
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::INSERT-CHAR-CLASS-TESTER in DEFMACRO
; compiling file "/usr/share/common-lisp/source/cl-ppcre/repetition-closures.lisp" (written 25 APR 2026 05:54:40 PM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        callable expression is not known to be a function

; 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
SIMPLE-COMPILER-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
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first argument is a CHARACTER, not a BASE-CHAR.
                        The second argument is a CHARACTER, not a BASE-CHAR.

;     (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-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 (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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

;     (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 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      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 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      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 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      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 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

;     (CL-PPCRE::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 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -13835058055282163710
                               13835058055282163711), not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163709 13835058055282163712)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a (UNSIGNED-BYTE 64).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

;     (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 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -13835058055282163710
                               13835058055282163711), not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163709 13835058055282163712)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a (UNSIGNED-BYTE 64).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      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 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -13835058055282163710
                               13835058055282163711), not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163709 13835058055282163712)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a (UNSIGNED-BYTE 64).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

; --> LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      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 MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -13835058055282163710
                               13835058055282163711), not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163709 13835058055282163712)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a (UNSIGNED-BYTE 64).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

; --> LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      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 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -13835058055282163710
                               13835058055282163711), not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163709 13835058055282163712)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a (UNSIGNED-BYTE 64).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

;     (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 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -13835058055282163710
                               13835058055282163711), not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163709 13835058055282163712)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a (UNSIGNED-BYTE 64).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

;     (CL-PPCRE::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 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -13835058055282163710
                               13835058055282163711), not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163709 13835058055282163712)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a (UNSIGNED-BYTE 64).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-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
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20), for:
      the first result of inline (signed-byte 64) arithmetic

;     (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 first result of inline (signed-byte 64) arithmetic
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20), for:
      the first result of inline (signed-byte 64) arithmetic

;     (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 first result of inline (signed-byte 64) arithmetic
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20), for:
      the first result of inline (signed-byte 64) arithmetic

;     (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 first result of inline (signed-byte 64) arithmetic
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20), for:
      the first result of inline (signed-byte 64) arithmetic

;     (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 first result of inline (signed-byte 64) arithmetic
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20), for:
      the first result of inline (signed-byte 64) arithmetic

;     (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 first result of inline (signed-byte 64) arithmetic
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20), for:
      the first result of inline (signed-byte 64) arithmetic

;     (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 first result of inline (signed-byte 64) arithmetic
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

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

;     (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> + AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

;     (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> SB-IMPL::XSUBTRACT AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

; in: DEFMETHOD CREATE-GREEDY-MATCHER (REPETITION T)
;     (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

;     (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> + AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

;     (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> SB-IMPL::XSUBTRACT AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        callable expression is not known to be a function

; 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
SIMPLE-COMPILER-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
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first argument is a CHARACTER, not a BASE-CHAR.
                        The second argument is a CHARACTER, not a BASE-CHAR.

;     (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-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 (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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      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 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -13835058055282163710
                               13835058055282163711), not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163709 13835058055282163712)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a (UNSIGNED-BYTE 64).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

;     (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 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -13835058055282163710
                               13835058055282163711), not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163709 13835058055282163712)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a (UNSIGNED-BYTE 64).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

;     (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 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -13835058055282163710
                               13835058055282163711), not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163709 13835058055282163712)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a (UNSIGNED-BYTE 64).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

;     (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 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -13835058055282163710
                               13835058055282163711), not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163709 13835058055282163712)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a (UNSIGNED-BYTE 64).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

;     (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 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      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 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -13835058055282163710
                               13835058055282163711), not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163709 13835058055282163712)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a (UNSIGNED-BYTE 64).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

; --> LET CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE IF LAMBDA FUNCTION LET 
; --> 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

;     (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE T)
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -13835058055282163710
                               13835058055282163711), not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163709 13835058055282163712)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a (UNSIGNED-BYTE 64).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

; --> LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      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 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -13835058055282163710
                               13835058055282163711), not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163709 13835058055282163712)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a (UNSIGNED-BYTE 64).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

; --> LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      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 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -13835058055282163710
                               13835058055282163711), not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163709 13835058055282163712)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -13835058055282163710
;                                13835058055282163711), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163709 13835058055282163712)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a (INTEGER -13835058055282163709
                                13835058055282163712), not a (UNSIGNED-BYTE 64).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a FIXNUM.
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a (INTEGER -9223372036854775808 9223372036854775806), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a (INTEGER -13835058055282163709
;                                 13835058055282163712), not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do -/SIGNED=>INTEGER (cost 10)
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
                                                                                         64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES
                       (INTEGER -13835058055282163710 13835058055282163711)
                       &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
      etc.

; --> LAMBDA FUNCTION LET 1+ 
; ==>
;   1
; 
; note: forced to do -/SIGNED=>INTEGER (cost 10)
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -13835058055282163710 13835058055282163711)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20), for:
      the first result of inline (signed-byte 64) arithmetic

; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first result of inline (signed-byte 64) arithmetic
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20), for:
      the first result of inline (signed-byte 64) arithmetic

;     (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 first result of inline (signed-byte 64) arithmetic
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20), for:
      the first result of inline (signed-byte 64) arithmetic

;     (CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE T)
; --> LAMBDA FUNCTION LET MIN 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first result of inline (signed-byte 64) arithmetic
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20), for:
      the first result of inline (signed-byte 64) arithmetic

;     (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 first result of inline (signed-byte 64) arithmetic
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20), for:
      the first result of inline (signed-byte 64) arithmetic

;     (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 first result of inline (signed-byte 64) arithmetic
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20), for:
      the first result of inline (signed-byte 64) arithmetic

;     (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 first result of inline (signed-byte 64) arithmetic
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20), for:
      the first result of inline (signed-byte 64) arithmetic

;     (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 first result of inline (signed-byte 64) arithmetic
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20), for:
      the first result of inline (signed-byte 64) arithmetic

;     (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 first result of inline (signed-byte 64) arithmetic
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

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

;     (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> + AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

;     (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> SB-IMPL::XSUBTRACT AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

; in: DEFMETHOD CREATE-NON-GREEDY-MATCHER (REPETITION T)
;     (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

;     (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> + AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

;     (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> SB-IMPL::XSUBTRACT AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        callable expression is not known to be a function

; 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
SIMPLE-COMPILER-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 (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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first argument is a CHARACTER, not a BASE-CHAR.
                        The second argument is a CHARACTER, not a BASE-CHAR.

;     (CHAR-EQUAL CL-PPCRE::CHR (SCHAR CL-PPCRE::*STRING* CL-PPCRE::CURR-POS))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

; in: DEFMETHOD CREATE-CONSTANT-REPETITION-MATCHER (REPETITION T)
;     (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

;     (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> + AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

;     (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> SB-IMPL::XSUBTRACT AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

;     (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a SINGLE-FLOAT.

;     (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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               SINGLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               DOUBLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        The operands might not be the same type.
; 
; note: unable to open code because: The operands might not be the same type.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

;     (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

;     (INCF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> + AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

;     (DECF (AREF CL-PPCRE::*REPEAT-COUNTERS* CL-PPCRE::REP-NUM))
; --> SB-IMPL::XSUBTRACT AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (VECTOR
                                                 FIXNUM), not a SIMPLE-ARRAY.

; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR FIXNUM), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a SINGLE-FLOAT.

; 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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               SINGLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               DOUBLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        The operands might not be the same type.
; 
; note: unable to open code because: The operands might not be the same type.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a SINGLE-FLOAT.
                        The second argument is a NUMBER, not a RATIONAL.

;     (= CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM 1)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a DOUBLE-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 DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               SINGLE-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 (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               DOUBLE-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 (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        The operands might not be the same type.
; 
; note: unable to open code because: The operands might not be the same type.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first 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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               SINGLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               DOUBLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        The operands might not be the same type.
; 
; note: unable to open code because: The operands might not be the same type.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a SINGLE-FLOAT.
                        The second argument is a T, not a SINGLE-FLOAT.

;     (EQL CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a SINGLE-FLOAT.
;   The second argument is a T, not a SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a DOUBLE-FLOAT.
                        The second argument is a T, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a DOUBLE-FLOAT.
;   The second argument is a T, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a SINGLE-FLOAT.
                        The second argument is a T, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a SINGLE-FLOAT.
;   The second argument is a T, not a SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a DOUBLE-FLOAT.
                        The second argument is a T, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a DOUBLE-FLOAT.
;   The second argument is a T, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a SINGLE-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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a SINGLE-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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a SINGLE-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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline float comparison (cost 3) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      unable to do inline float comparison (cost 3) because:
      The first argument is a T, not a DOUBLE-FLOAT.
      The second argument is a T, not a DOUBLE-FLOAT.

;     (= CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM 1)
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The second argument is a T, not a (UNSIGNED-BYTE 64).
      unable to do inline (signed-byte 64) comparison (cost 6) because:
      The first argument is a T, not a (SIGNED-BYTE 64).
      The second argument is a T, not a (SIGNED-BYTE 64).

;     (EQL CL-PPCRE::MINIMUM CL-PPCRE::MAXIMUM)
; 
; note: forced to do full call
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       unable to do inline (signed-byte 64) comparison (cost 6) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The second argument is a T, not a (SIGNED-BYTE 64).
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The second argument is a T, not a (UNSIGNED-BYTE 64).
      unable to do inline (signed-byte 64) comparison (cost 6) because:
      The first argument is a T, not a (SIGNED-BYTE 64).
      The second argument is a T, not a (SIGNED-BYTE 64).
; 
; note: forced to do full call
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       unable to do inline (signed-byte 64) comparison (cost 6) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The second argument is a T, not a (SIGNED-BYTE 64).
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a T, not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      etc.

;     (PLUSP CL-PPCRE::MIN-LEN)
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a T, not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      etc.

;     (PLUSP CL-PPCRE::LEN)
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a T, not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      etc.

;     (PLUSP CL-PPCRE::MIN-LEN)
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       etc.


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/cl-ppcre/repetition-closures-tmpE0PA0714.fasl
; compilation finished in 0:00:00.787
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::INCF-AFTER in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::GREEDY-CONSTANT-LENGTH-CLOSURE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::NON-GREEDY-CONSTANT-LENGTH-CLOSURE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::CONSTANT-REPETITION-CONSTANT-LENGTH-CLOSURE in DEFMACRO
; compiling file "/usr/share/common-lisp/source/cl-ppcre/scanner.lisp" (written 25 APR 2026 05:54:40 PM):
SIMPLE-COMPILER-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.

; 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 (SCHAR CL-PPCRE::*STRING* CL-PPCRE::I)
;               (SCHAR CL-PPCRE::PATTERN CL-PPCRE::J))
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

;     (LENGTH CL-PPCRE::PATTERN)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first argument is a CHARACTER, not a BASE-CHAR.

;     (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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

;     (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.
SIMPLE-COMPILER-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-CHAR-SEARCHER
;     (CL-PPCRE::CHAR-SEARCHER-AUX :CASE-INSENSITIVE-P T)
; --> FUNCTION AND IF LOOP BLOCK LET LET TAGBODY WHEN IF SETQ AND IF 
; ==>
;   (CHAR-EQUAL (SCHAR CL-PPCRE::*STRING* CL-PPCRE::I) CL-PPCRE::CHR)
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; 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
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, 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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; --> 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
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, 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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-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)
;       (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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; --> 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
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, 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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-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::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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; --> 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
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, 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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-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))
;       (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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; --> 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
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, 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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-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::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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; --> 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
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, 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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-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 (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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; --> 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
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, 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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-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 (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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; --> 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
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, 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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-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) 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The first 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.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      due to type uncertainty:
                        The second argument is a CHARACTER, not a BASE-CHAR.
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The second argument is a CHARACTER, not a BASE-CHAR.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &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)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a NUMBER, not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      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 full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &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 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 full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a NUMBER, not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      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 full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &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 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 full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a NUMBER, not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      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 full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &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 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 full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a NUMBER, not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      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 full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &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 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 full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a NUMBER, not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      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 full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &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 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 full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a NUMBER, not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      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 full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &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 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 full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a NUMBER, not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      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 full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &OPTIONAL).
      etc.

;     (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 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 full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a NUMBER, not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
      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 full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

; --> FUNCTION BLOCK LET* LABELS COND IF PROGN WHEN IF BLOCK LOOP BLOCK TAGBODY 
; --> PROGN LET COND IF IF INCF SETQ 
; ==>
;   (+ 1 CL-PPCRE::*END-STRING-POS*)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: doing signed word to integer coercion (cost 20) from TRY-POS

;     (FUNCALL CL-PPCRE::END-STRING-TEST CL-PPCRE::TRY-POS)
; 
; note: doing signed word to integer coercion (cost 20) from TRY-POS
SIMPLE-COMPILER-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 /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/cl-ppcre/scanner-tmpJRWHHVG0.fasl
; compilation finished in 0:00:01.105
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::BMH-MATCHER-AUX in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::CHAR-SEARCHER-AUX in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::INSERT-ADVANCE-FN in DEFMACRO
; compiling file "/usr/share/common-lisp/source/cl-ppcre/api.lisp" (written 25 APR 2026 05:54:40 PM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

; 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.
SIMPLE-COMPILER-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 LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a SINGLE-FLOAT.

; 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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a SINGLE-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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               SINGLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               DOUBLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        The operands might not be the same type.
; 
; note: unable to open code because: The operands might not be the same type.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a SINGLE-FLOAT.

;     (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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a SINGLE-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 SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               SINGLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               DOUBLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        The operands might not be the same type.
; 
; note: unable to open code because: The operands might not be the same type.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a T, not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      etc.

;     (PLUSP (CL-PPCRE::LEN CL-PPCRE::END-STRING))
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a T, not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      etc.

;     (PLUSP (CL-PPCRE::LEN CL-PPCRE::STARTS-WITH))
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

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

;     (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
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR LIST
                                                    (AND VECTOR
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           BASE-CHAR))
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           CHARACTER)))
                                                    SB-KERNEL:EXTENDED-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 VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                    (NOT (SIMPLE-ARRAY CHARACTER)))
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          NULL
                                                                                          (SIMPLE-ARRAY
                                                                                           *
                                                                                           (*))).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR NULL
;                                                                        (SIMPLE-ARRAY
;                                                                         * (*))).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          SIMPLE-BASE-STRING
                                                                                          NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
;                                                                     SIMPLE-BASE-STRING
;                                                                     NULL).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

; 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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR LIST
                                                    (AND VECTOR
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           BASE-CHAR))
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           CHARACTER)))
                                                    SB-KERNEL:EXTENDED-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 VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                    (NOT (SIMPLE-ARRAY CHARACTER)))
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          NULL
                                                                                          (SIMPLE-ARRAY
                                                                                           *
                                                                                           (*))).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR NULL
;                                                                        (SIMPLE-ARRAY
;                                                                         * (*))).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          SIMPLE-BASE-STRING
                                                                                          NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
;                                                                     SIMPLE-BASE-STRING
;                                                                     NULL).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

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

;     (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
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR LIST
                                                    (AND VECTOR
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           BASE-CHAR))
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           CHARACTER)))
                                                    SB-KERNEL:EXTENDED-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 VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                    (NOT (SIMPLE-ARRAY CHARACTER)))
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          NULL
                                                                                          (SIMPLE-ARRAY
                                                                                           *
                                                                                           (*))).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR NULL
;                                                                        (SIMPLE-ARRAY
;                                                                         * (*))).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          SIMPLE-BASE-STRING
                                                                                          NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
;                                                                     SIMPLE-BASE-STRING
;                                                                     NULL).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

; 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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

;     (FUNCALL CL-PPCRE::SUBSTR-FN CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START
;              CL-PPCRE::MATCH-END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
&OPTIONAL-AND-&KEY-IN-LAMBDA-LIST: &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-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.  ... {10044A76CF}>
;       (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)
&OPTIONAL-AND-&KEY-IN-LAMBDA-LIST: &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
;     (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,
;   ... {10048767EF}>
;       (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)
&OPTIONAL-AND-&KEY-IN-LAMBDA-LIST: &OPTIONAL and &KEY found in the same lambda list: (MATCH-VAR
                                                                                      REGEX
                                                                                      TARGET-STRING
                                                                                      &OPTIONAL
                                                                                      RESULT-FORM
                                                                                      &KEY
                                                                                      START
                                                                                      END
                                                                                      SHAREDP)

; 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... {10049D000F}>
;       (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)
&OPTIONAL-AND-&KEY-IN-LAMBDA-LIST: &OPTIONAL and &KEY found in the same lambda list: (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... {1004B7D04F}>
;       (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)
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

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

;     (CL-PPCRE:DO-MATCHES (CL-PPCRE::S CL-PPCRE::E CL-PPCRE::REGEX
;                           CL-PPCRE::TARGET-STRING COUNT :START CL-PPCRE::START
;                           :END CL-PPCRE::END)
;       (INCF COUNT))
; --> 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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR LIST
                                                    (AND VECTOR
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           BASE-CHAR))
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           CHARACTER)))
                                                    SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; --> LET BLOCK LET* SETQ 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 VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                    (NOT (SIMPLE-ARRAY CHARACTER)))
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          NULL
                                                                                          (SIMPLE-ARRAY
                                                                                           *
                                                                                           (*))).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR NULL
;                                                                        (SIMPLE-ARRAY
;                                                                         * (*))).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          SIMPLE-BASE-STRING
                                                                                          NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
;                                                                     SIMPLE-BASE-STRING
;                                                                     NULL).
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a SINGLE-FLOAT.
                        The second argument is a NUMBER, not a RATIONAL.

; --> LET BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ IF 
; ==>
;   (= CL-PPCRE::S CL-PPCRE::E)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a DOUBLE-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 DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               SINGLE-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 (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               DOUBLE-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 (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        The operands might not be the same type.
; 
; note: unable to open code because: The operands might not be the same type.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.

; --> LET BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ IF 1+ 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
                                                             (UNSIGNED-BYTE 64)
                                                             &OPTIONAL).
      etc.

;     (INCF COUNT)
; ==>
;   (+ 1 COUNT)
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
;                                                              (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline float comparison (cost 3) because:
      The first argument is a (NOT NULL), not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      unable to do inline float comparison (cost 3) because:
      The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
      The second argument is a T, not a DOUBLE-FLOAT.

;     (CL-PPCRE:DO-MATCHES (CL-PPCRE::S CL-PPCRE::E CL-PPCRE::REGEX
;                           CL-PPCRE::TARGET-STRING COUNT :START CL-PPCRE::START
;                           :END CL-PPCRE::END)
;       (INCF COUNT))
; --> LET BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ IF 
; ==>
;   (= CL-PPCRE::S CL-PPCRE::E)
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (NOT NULL), not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

; --> LET BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ IF 1+ 
; ==>
;   1
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

; 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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR LIST
                                                    (AND VECTOR
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           BASE-CHAR))
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           CHARACTER)))
                                                    SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; --> LET BLOCK LET* SETQ 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 VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                    (NOT (SIMPLE-ARRAY CHARACTER)))
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          NULL
                                                                                          (SIMPLE-ARRAY
                                                                                           *
                                                                                           (*))).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR NULL
;                                                                        (SIMPLE-ARRAY
;                                                                         * (*))).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          SIMPLE-BASE-STRING
                                                                                          NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
;                                                                     SIMPLE-BASE-STRING
;                                                                     NULL).
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a SINGLE-FLOAT.
                        The second argument is a NUMBER, not a RATIONAL.

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

; --> LET BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ IF 1+ 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline float comparison (cost 3) because:
      The first argument is a (NOT NULL), not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      unable to do inline float comparison (cost 3) because:
      The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
      The second argument is a T, not a DOUBLE-FLOAT.

; --> LET BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ IF 
; ==>
;   (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (NOT NULL), not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

; --> LET BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ IF 1+ 
; ==>
;   1
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

; 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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR LIST
                                                    (AND VECTOR
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           BASE-CHAR))
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           CHARACTER)))
                                                    SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; --> LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* SETQ 
; --> 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 VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                    (NOT (SIMPLE-ARRAY CHARACTER)))
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          NULL
                                                                                          (SIMPLE-ARRAY
                                                                                           *
                                                                                           (*))).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR NULL
;                                                                        (SIMPLE-ARRAY
;                                                                         * (*))).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          SIMPLE-BASE-STRING
                                                                                          NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
;                                                                     SIMPLE-BASE-STRING
;                                                                     NULL).
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a SINGLE-FLOAT.
                        The second argument is a NUMBER, 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 IF 
; ==>
;   (= #:MATCH-START2 #:MATCH-END3)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a DOUBLE-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 DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               SINGLE-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 (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               DOUBLE-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 (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        The operands might not be the same type.
; 
; note: unable to open code because: The operands might not be the same type.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, 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 IF 1+ 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline float comparison (cost 3) because:
      The first argument is a (NOT NULL), not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      unable to do inline float comparison (cost 3) because:
      The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
      The second argument is a T, not a DOUBLE-FLOAT.

; --> LET CL-PPCRE:DO-MATCHES CL-PPCRE:DO-SCANS LET BLOCK LET* LOOP BLOCK 
; --> TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION SETQ IF 
; ==>
;   (= #:MATCH-START2 #:MATCH-END3)
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (NOT NULL), not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      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 IF 1+ 
; ==>
;   1
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

; 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.
SIMPLE-COMPILER-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 (PLUSP 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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR LIST
                                                    (AND VECTOR
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           BASE-CHAR))
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           CHARACTER)))
                                                    SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; --> BLOCK LET* SETQ 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 VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                    (NOT (SIMPLE-ARRAY CHARACTER)))
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          NULL
                                                                                          (SIMPLE-ARRAY
                                                                                           *
                                                                                           (*))).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR NULL
;                                                                        (SIMPLE-ARRAY
;                                                                         * (*))).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          SIMPLE-BASE-STRING
                                                                                          NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
;                                                                     SIMPLE-BASE-STRING
;                                                                     NULL).
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a SINGLE-FLOAT.
                        The second argument is a NUMBER, not a RATIONAL.

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

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

;     (PLUSP CL-PPCRE::LIMIT)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

;     (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 MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET LET 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET TAGBODY 
; --> SB-LOOP::LOOP-DESETQ SETQ AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-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
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a SINGLE-FLOAT.
                        The second argument is a NUMBER, not a RATIONAL.

;     (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 (PLUSP 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 IF 
; ==>
;   (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a DOUBLE-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 DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               SINGLE-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 (COMPLEX SINGLE-FLOAT).
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a (COMPLEX
                                                               DOUBLE-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 (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        The operands might not be the same type.
; 
; note: unable to open code because: The operands might not be the same type.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.

; --> BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ IF 1+ 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a SINGLE-FLOAT.
                        The second argument is a REAL, not a RATIONAL.

;     (> CL-PPCRE::THIS-END CL-PPCRE::THIS-START)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
                        The second argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline float comparison (cost 3) because:
      The first argument is a (NOT NULL), not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      unable to do inline float comparison (cost 3) because:
      The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
      The second argument is a T, not a DOUBLE-FLOAT.

;     (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (NOT NULL), not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline float comparison (cost 3) because:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      unable to do inline float comparison (cost 3) because:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a T, not a DOUBLE-FLOAT.

;     (= CL-PPCRE::MATCH-START (CAR CL-PPCRE::POS-LIST))
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a (NOT NULL), not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
      etc.

;     (PLUSP CL-PPCRE::LIMIT)
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
                                                             (UNSIGNED-BYTE 64)
                                                             &OPTIONAL).
      etc.

;     (INCF CL-PPCRE::COUNTER)
; ==>
;   (+ 1 CL-PPCRE::COUNTER)
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
;                                                              (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline float comparison (cost 3) because:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a SINGLE-FLOAT.
      unable to do inline float comparison (cost 3) because:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.

;     (CL-PPCRE:DO-SCANS (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 (PLUSP 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 IF 
; ==>
;   (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

; --> BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ IF 1+ 
; ==>
;   1
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline float comparison (cost 3) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a (NOT NULL), not a SINGLE-FLOAT.
      unable to do inline float comparison (cost 3) because:
      The first argument is a T, not a DOUBLE-FLOAT.
      The second argument is a (NOT NULL), not a DOUBLE-FLOAT.
      etc.

;     (> CL-PPCRE::THIS-END CL-PPCRE::THIS-START)
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a (NOT NULL), not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a (NOT NULL), not a DOUBLE-FLOAT.
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a STRING, not a SIMPLE-ARRAY.

; 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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        expand inline
                      because:
                        upgraded array element type not known at compile time

; 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
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a STRING, not a SIMPLE-ARRAY.

;     (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-ARRAY.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The second argument is a (NOT NULL), not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The second argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
      etc.

;     (< CL-PPCRE::FROM CL-PPCRE::MATCH-START)
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a (NOT NULL), not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The second argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a (OR NULL INTEGER), not a FIXNUM.
      The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
                                                                &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (OR NULL INTEGER), not a (UNSIGNED-BYTE 64).
      The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
                                                         (UNSIGNED-BYTE 64)
                                                         &OPTIONAL).
      etc.

;     (1-
;      (PARSE-INTEGER CL-PPCRE::REPLACEMENT-STRING :START CL-PPCRE::PARSE-START
;                     :JUNK-ALLOWED T))
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR NULL INTEGER), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (OR NULL INTEGER), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do <-INTEGER-FIXNUM (cost 10)
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a INTEGER, not a FIXNUM.

;     (< CL-PPCRE::TOKEN 0)
; 
; note: forced to do <-INTEGER-FIXNUM (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

; in: DEFUN BUILD-REPLACEMENT
;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START
;                        CL-PPCRE::MATCH-END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a ARRAY, not a SIMPLE-ARRAY.

;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::REG-START
;                        CL-PPCRE::REG-END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a ARRAY, not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a ARRAY, not a SIMPLE-ARRAY.

;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START
;                        CL-PPCRE::MATCH-END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a ARRAY, not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        can't determine sequence argument type

;     (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
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a ARRAY, not a SIMPLE-ARRAY.

;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START
;                        CL-PPCRE::MATCH-END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a ARRAY, not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        TOKEN is not known to be a function

;     (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:
;   TOKEN is not known to be a function
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        can't determine sequence argument type

;     (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
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        TOKEN is not known to be a function

;     (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:
;   TOKEN is not known to be a function
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START
;                        CL-PPCRE::MATCH-END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.

;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::REG-START
;                        CL-PPCRE::REG-END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.
                        The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a ARRAY, not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a ARRAY, not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a (NOT NULL), not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a (NOT NULL), not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a (NOT NULL), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a (NOT NULL), not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a (NOT NULL), not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a (NOT NULL), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do <-INTEGER-FIXNUM (cost 10)
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a INTEGER, not a FIXNUM.

;     (>= CL-PPCRE::TOKEN CL-PPCRE::REG-BOUND)
; 
; note: forced to do <-INTEGER-FIXNUM (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
                                                             (UNSIGNED-BYTE 64)
                                                             &OPTIONAL).
      etc.

;     (1+ CL-PPCRE::TOKEN)
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
;                                                              (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &OPTIONAL).
      etc.

;     (CL-PPCRE::NSUBSEQ CL-PPCRE::TARGET-STRING CL-PPCRE::MATCH-START
;                        CL-PPCRE::MATCH-END)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 2) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &OPTIONAL).
      etc.
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

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

; 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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR LIST
                                                    (AND VECTOR
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           BASE-CHAR))
                                                         (NOT
                                                          (SIMPLE-ARRAY
                                                           CHARACTER)))
                                                    SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

; --> BLOCK LET* SETQ 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 VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                    (NOT (SIMPLE-ARRAY CHARACTER)))
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          NULL
                                                                                          (SIMPLE-ARRAY
                                                                                           *
                                                                                           (*))).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR NULL
;                                                                        (SIMPLE-ARRAY
;                                                                         * (*))).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a (OR LIST
                                                     (AND VECTOR
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            BASE-CHAR))
                                                          (NOT
                                                           (SIMPLE-ARRAY
                                                            CHARACTER)))
                                                     SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
                                                                                          SIMPLE-BASE-STRING
                                                                                          NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST
;                                (AND VECTOR (NOT (SIMPLE-ARRAY BASE-CHAR))
;                                     (NOT (SIMPLE-ARRAY CHARACTER)))
;                                SB-KERNEL:EXTENDED-SEQUENCE), not a (OR
;                                                                     SIMPLE-BASE-STRING
;                                                                     NULL).
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a NUMBER, not a SINGLE-FLOAT.
                        The second argument is a NUMBER, not a RATIONAL.

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

; --> BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ IF 1+ 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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 LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline float comparison (cost 3) because:
      The first argument is a (NOT NULL), not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
      unable to do inline float comparison (cost 3) because:
      The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
      The second argument is a T, not a DOUBLE-FLOAT.

;     (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 IF 
; ==>
;   (= CL-PPCRE::MATCH-START CL-PPCRE::MATCH-END)
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (NOT NULL), not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (NOT NULL), not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: forced to do full call
      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).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

; --> BLOCK LET* LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION SETQ IF 1+ 
; ==>
;   1
; 
; note: forced to do full call
;       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).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
&OPTIONAL-AND-&KEY-IN-LAMBDA-LIST: &OPTIONAL and &KEY found in the same lambda list: (REGEX
                                                                                      &OPTIONAL
                                                                                      PACKAGES
                                                                                      &KEY
                                                                                      (CASE-INSENSITIVE
                                                                                       T))

; 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 (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... {100450F87F}>
;       (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))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       #<(SIMPLE-BASE-STRING
;          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... {100450FC2F}>
;       (DECLARE (OPTIMIZE SPEED (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))
&OPTIONAL-AND-&KEY-IN-LAMBDA-LIST: &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 ... {1004A45B6F}>
;       (DECLARE (OPTIMIZE SPEED (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))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       #<(SIMPLE-BASE-STRING
;          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 ... {1004A45F7F}>
;       (DECLARE (OPTIMIZE SPEED (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 /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/cl-ppcre/api-tmp4WZVROCX.fasl
; compilation finished in 0:00:00.876
COMPILE-WARNED-WARNING: Lisp compilation had style-warnings while
                        compiling #<CL-SOURCE-FILE "cl-ppcre" "api">
WARNING:
   Lisp compilation had style-warnings while
   compiling #<CL-SOURCE-FILE "cl-ppcre" "api">
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE:REGISTER-GROUPS-BIND in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE:DO-SCANS in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE:DO-MATCHES in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE:DO-MATCHES-AS-STRINGS in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE:DO-REGISTER-GROUPS in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE::REGEX-APROPOS-AUX in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining CL-PPCRE:DEFINE-PARSE-TREE-SYNONYM in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/package.lisp" (written 05 FEB 2026 08:57:08 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/package-tmpA0I3UKX8.fasl
; compilation finished in 0:00:00.029
; compiling file "/usr/share/common-lisp/source/clx/depdefs.lisp" (written 05 FEB 2026 08:57:08 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/depdefs-tmp267Y2N80.fasl
; compilation finished in 0:00:00.507
REDEFINITION-WITH-DEFUN: redefining XLIB::%REEVALUATE-CONSTANT in DEFUN
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DEFINE-CONSTANT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DEFCONSTANT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITH-VECTOR in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITHIN-DEFINITION in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::RESOURCE-ID-MAP-TEST in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::ATOM-CACHE-MAP-TEST in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::KEYSYM->CHARACTER-MAP-TEST in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX+ in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX-LOGAND in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX-LOGIOR in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX- in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX* in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX1+ in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX1- in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX-INCF in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX-DECF in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX-MIN in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX-MAX in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX-FLOOR in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX-CEILING in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX-TRUNCATE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX-MOD in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX-ASH in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX-PLUSP in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX-ZEROP in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX-EVENP in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX-ODDP in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX> in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX= in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX< in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX>= in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INDEX<= in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DEF-CLX-CLASS in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/clx.lisp" (written 05 FEB 2026 08:57:08 AM):
CODE-DELETION-NOTE: deleting unreachable code
CODE-DELETION-NOTE: deleting unreachable code

; 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
CODE-DELETION-NOTE: deleting unreachable code
CODE-DELETION-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
CODE-DELETION-NOTE: deleting unreachable code
CODE-DELETION-NOTE: deleting unreachable code

; in: DEFUN ENCODE-MODIFIER-MASK
;     (XLIB::X-TYPE-ERROR XLIB:MODIFIER-MASK 'XLIB:MODIFIER-MASK)
; 
; note: deleting unreachable code
CODE-DELETION-NOTE: deleting unreachable code
CODE-DELETION-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
CODE-DELETION-NOTE: deleting unreachable code
CODE-DELETION-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 /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/clx-tmpOUPE5FSJ.fasl
; compilation finished in 0:00:01.527
; compiling file "/usr/share/common-lisp/source/clx/dependent.lisp" (written 05 FEB 2026 08:57:08 AM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR (FLOAT 0.0 1.0)
                                                    (RATIONAL 0
                                                              1)), not a SINGLE-FLOAT.

; file: /usr/share/common-lisp/source/clx/dependent.lisp
; in: DEFUN RGB-VAL->CARD16
;     (ROUND (THE XLIB:RGB-VAL XLIB::VALUE) 1.5259022e-5)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (FLOAT 0.0 1.0)
;                               (RATIONAL 0 1)), not a SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR (FLOAT 0.0 1.0)
                                                    (RATIONAL 0
                                                              1)), not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (FLOAT 0.0 1.0)
;                               (RATIONAL 0 1)), not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR
                                                 (SINGLE-FLOAT -6.2831855
                                                  6.2831855)
                                                 (DOUBLE-FLOAT
                                                  -6.283185307179586d0
                                                  6.283185307179586d0)
                                                 (RATIONAL
                                                  -884279719003555/140737488355328
                                                  884279719003555/140737488355328)), not a SINGLE-FLOAT.

; in: DEFUN RADIANS->INT16
;     (ROUND (THE XLIB:ANGLE XLIB::VALUE) 2.727077e-4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (SINGLE-FLOAT -6.2831855 6.2831855)
;                               (DOUBLE-FLOAT -6.283185307179586d0
;                                6.283185307179586d0)
;                               (RATIONAL -884279719003555/140737488355328
;                                         884279719003555/140737488355328)), not a SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR
                                                 (SINGLE-FLOAT -6.2831855
                                                  6.2831855)
                                                 (DOUBLE-FLOAT
                                                  -6.283185307179586d0
                                                  6.283185307179586d0)
                                                 (RATIONAL
                                                  -884279719003555/140737488355328
                                                  884279719003555/140737488355328)), not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (SINGLE-FLOAT -6.2831855 6.2831855)
;                               (DOUBLE-FLOAT -6.283185307179586d0
;                                6.283185307179586d0)
;                               (RATIONAL -884279719003555/140737488355328
;                                         884279719003555/140737488355328)), not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code INTEGER to RATIO comparison
                      due to type uncertainty:
                        The first argument is a RATIONAL, not a INTEGER.

;     (DEFUN XLIB::RADIANS->INT16 (XLIB::VALUE)
;       (DECLARE (TYPE XLIB:ANGLE XLIB::VALUE))
;       (DECLARE (XLIB::CLX-VALUES XLIB:INT16))
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 1) (DEBUG 1)))
;       (THE XLIB:INT16 (VALUES (ROUND (THE XLIB:ANGLE XLIB::VALUE) 2.727077e-4))))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   open-code INTEGER to RATIO comparison
; due to type uncertainty:
;   The first argument is a RATIONAL, not a INTEGER.
SIMPLE-COMPILER-NOTE: unable to
                        open-code INTEGER to RATIO comparison
                      due to type uncertainty:
                        The first argument is a (RATIONAL
                                                 -884279719003555/140737488355328), not a INTEGER.
; 
; note: unable to
;   open-code INTEGER to RATIO comparison
; due to type uncertainty:
;   The first argument is a (RATIONAL
;                            -884279719003555/140737488355328), not a INTEGER.
&OPTIONAL-AND-&KEY-IN-LAMBDA-LIST: &OPTIONAL and &KEY found in the same lambda list: (LOCK
                                                                                      DISPLAY
                                                                                      &OPTIONAL
                                                                                      (WHOSTATE
                                                                                       CLX wait)
                                                                                      &KEY
                                                                                      TIMEOUT)

; 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))
;       `(SB-THREAD:WITH-RECURSIVE-LOCK (,XLIB::LOCK
;                                        ,@(WHEN XLIB::TIMEOUT
;                                            `(:TIMEOUT ,XLIB::TIMEOUT)))
;          ,@XLIB::BODY))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (LOCK DISPLAY &OPTIONAL
;                                                      (WHOSTATE CLX wait) &KEY
;                                                      TIMEOUT)
CODE-DELETION-NOTE: deleting unreachable code
CODE-DELETION-NOTE: deleting unreachable code

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

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

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

; in: DEFMACRO WRITE-IMAGE-ASSEMBLE-BYTES
;     (SETQ XLIB::BYTES (REVERSE XLIB::BYTES))
; 
; note: deleting unreachable code
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a ARRAY.

; in: DEFUN COPY-BIT-RECT
;     (SB-KERNEL:WITH-ARRAY-DATA ((XLIB::SDATA XLIB::SOURCE) (XLIB::SSTART)
;                                 (XLIB::SEND))
;       (DECLARE (IGNORE XLIB::SEND))
;       (SB-KERNEL:WITH-ARRAY-DATA ((XLIB::DDATA XLIB::DEST) (XLIB::DSTART)
;                                   (XLIB::DEND))
;         (DECLARE (IGNORE XLIB::DEND))
;         (ASSERT (AND (ZEROP XLIB::SSTART) (ZEROP XLIB::DSTART)))
;         (DO ((XLIB::SRC-IDX # #)
;              (XLIB::DEST-IDX # #)
;              (COUNT XLIB::HEIGHT #))
;             ((ZEROP COUNT))
;           (DECLARE (TYPE XLIB:ARRAY-INDEX XLIB::SRC-IDX XLIB::DEST-IDX COUNT))
;           (SB-KERNEL:UB1-BASH-COPY XLIB::SDATA XLIB::SRC-IDX XLIB::DDATA
;                                    XLIB::DEST-IDX XLIB::WIDTH))))
; --> LET LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL COND IF NOT 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        inline non-SIMPLE-vector-handling logic
                      due to type uncertainty:
                        The first argument is a (AND ARRAY
                                                     (NOT
                                                      (SIMPLE-ARRAY *
                                                       (*)))), not a (OR VECTOR
                                                                         SIMPLE-ARRAY).

; --> LET LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL COND IF THE 
; ==>
;   (SB-KERNEL:%WITH-ARRAY-DATA #:N-ARRAY0 #:N-SVALUE1 #:N-EVALUE2)
; 
; note: unable to
;   inline non-SIMPLE-vector-handling logic
; due to type uncertainty:
;   The first argument is a (AND ARRAY (NOT (SIMPLE-ARRAY * (*)))), not a (OR
;                                                                          VECTOR
;                                                                          SIMPLE-ARRAY).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a ARRAY.

;     (SB-KERNEL:WITH-ARRAY-DATA ((XLIB::DDATA XLIB::DEST) (XLIB::DSTART)
;                                 (XLIB::DEND))
;       (DECLARE (IGNORE XLIB::DEND))
;       (ASSERT (AND (ZEROP XLIB::SSTART) (ZEROP XLIB::DSTART)))
;       (DO ((XLIB::SRC-IDX (XLIB::INDEX+ # XLIB::SX #)
;                           (XLIB::INDEX+ XLIB::SRC-IDX XLIB::SOURCE-WIDTH))
;            (XLIB::DEST-IDX (XLIB::INDEX+ # XLIB::DX #)
;                            (XLIB::INDEX+ XLIB::DEST-IDX XLIB::DEST-WIDTH))
;            (COUNT XLIB::HEIGHT (1- COUNT)))
;           ((ZEROP COUNT))
;         (DECLARE (TYPE XLIB:ARRAY-INDEX XLIB::SRC-IDX XLIB::DEST-IDX COUNT))
;         (SB-KERNEL:UB1-BASH-COPY XLIB::SDATA XLIB::SRC-IDX XLIB::DDATA
;                                  XLIB::DEST-IDX XLIB::WIDTH)))
; --> LET LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL COND IF NOT 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        inline non-SIMPLE-vector-handling logic
                      due to type uncertainty:
                        The first argument is a (AND ARRAY
                                                     (NOT
                                                      (SIMPLE-ARRAY *
                                                       (*)))), not a (OR VECTOR
                                                                         SIMPLE-ARRAY).

; --> LET LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL COND IF THE 
; ==>
;   (SB-KERNEL:%WITH-ARRAY-DATA #:N-ARRAY5 #:N-SVALUE6 #:N-EVALUE7)
; 
; note: unable to
;   inline non-SIMPLE-vector-handling logic
; due to type uncertainty:
;   The first argument is a (AND ARRAY (NOT (SIMPLE-ARRAY * (*)))), not a (OR
;                                                                          VECTOR
;                                                                          SIMPLE-ARRAY).
CODE-DELETION-NOTE: deleting unreachable code
CODE-DELETION-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
CODE-DELETION-NOTE: deleting unreachable code
CODE-DELETION-NOTE: deleting unreachable code

; 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 /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/dependent-tmpIGHCU6ZA.fasl
; compilation finished in 0:00:00.655
COMPILE-WARNED-WARNING: Lisp compilation had style-warnings while
                        compiling #<CLX-SOURCE-FILE "clx" "dependent">
WARNING:
   Lisp compilation had style-warnings while
   compiling #<CLX-SOURCE-FILE "clx" "dependent">
REDEFINITION-WITH-DEFUN: redefining XLIB::DECLARE-BUFMAC in DEFUN
REDEFINITION-WITH-DEFUN: redefining XLIB::DECLARE-BUFFUN in DEFUN
REDEFINITION-WITH-DEFMACRO: redefining XLIB::HOLDING-LOCK in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITHOUT-ABORTS in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITHOUT-INTERRUPTS in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CONDITIONAL-STORE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WRAP-BUF-OUTPUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WRAP-BUF-INPUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITH-STACK-LIST in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITH-STACK-LIST* in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITH-GCONTEXT-BINDINGS in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::TYPE? in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::USE-CLOSURES in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITH-UNDERLYING-SIMPLE-VECTOR in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::READ-IMAGE-LOAD-BYTE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::READ-IMAGE-ASSEMBLE-BYTES in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WRITE-IMAGE-LOAD-BYTE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WRITE-IMAGE-ASSEMBLE-BYTES in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/common.lisp" (written 05 FEB 2026 08:57:08 AM):
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a (OR (FLOAT 0.0)
                                                    (RATIONAL
                                                     0)), not a SINGLE-FLOAT.

; file: /usr/share/common-lisp/source/clx/common.lisp
; in: DEFUN BUFFER-READ-DEFAULT
;     (ZEROP XLIB::TIMEOUT)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (FLOAT 0.0) (RATIONAL 0)), not a SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open-code FLOAT to RATIONAL comparison
                      due to type uncertainty:
                        The first argument is a (OR (FLOAT 0.0)
                                                    (RATIONAL
                                                     0)), not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        open code
                      because:
                        The operands might not be the same type.
; 
; note: unable to open code because: The operands might not be the same type.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum comparison (cost 4) because:
      The first argument is a RATIONAL, not a FIXNUM.
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a RATIONAL, not a (UNSIGNED-BYTE 64).
      etc.

;     (DEFUN XLIB::BUFFER-READ-DEFAULT
;            (XLIB:DISPLAY VECTOR XLIB::START XLIB::END XLIB::TIMEOUT)
;       (DECLARE (TYPE XLIB:DISPLAY XLIB:DISPLAY)
;                (TYPE XLIB::BUFFER-BYTES VECTOR)
;                (TYPE XLIB:ARRAY-INDEX XLIB::START XLIB::END)
;                (TYPE (OR NULL (REAL 0 *)) XLIB::TIMEOUT))
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 1) (DEBUG 1)))
;       (IF (AND (NOT (NULL XLIB::TIMEOUT)) (ZEROP XLIB::TIMEOUT) (NOT (LISTEN #)))
;           :TIMEOUT
;           (LET ((XLIB::N #))
;             (COND (# NIL) (# :END-OF-FILE) (T :TRUNCATED)))))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: forced to do full call
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a RATIONAL, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a RATIONAL, not a (UNSIGNED-BYTE 64).
;       etc.


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/common-tmpBO0TUGLK.fasl
; compilation finished in 0:00:00.027
; compiling file "/usr/share/common-lisp/source/clx/macros.lisp" (written 05 FEB 2026 08:57:08 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/macros-tmpIIXPIQNW.fasl
; compilation finished in 0:00:01.443
REDEFINITION-WITH-DEFMACRO: redefining XLIB::TYPE-CHECK in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::REQUIRED-ARG in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::LROUND in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WROUND in DEFMACRO
REDEFINITION-WITH-DEFUN: redefining XLIB::GETIFY in DEFUN
REDEFINITION-WITH-DEFUN: redefining XLIB::PUTIFY in DEFUN
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DEFINE-ACCESSOR in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CARD32-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CARD32-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CARD29-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CARD29-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CARD16-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CARD16-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CARD8-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CARD8-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INTEGER-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INTEGER-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INT16-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INT16-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::RGB-VAL-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::RGB-VAL-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::ANGLE-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::ANGLE-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::BIT-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::BIT-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::BOOLEAN-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::BOOLEAN-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DRAWABLE-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DRAWABLE-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WINDOW-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WINDOW-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::PIXMAP-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::PIXMAP-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CURSOR-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CURSOR-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::COLORMAP-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::COLORMAP-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::FONT-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::FONT-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::KEYWORD-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::KEYWORD-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::RESOURCE-ID-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::RESOURCE-ID-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::RESOURCE-ID-OR-NIL-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::RESOURCE-ID-OR-NIL-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CHAR-INFO-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MEMBER8-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MEMBER8-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MEMBER8-PUT-PREDICATING in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MEMBER16-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MEMBER16-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MEMBER16-PUT-PREDICATING in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MEMBER-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MEMBER-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MEMBER-PUT-PREDICATING in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MEMBER-VECTOR-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MEMBER-VECTOR-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MEMBER-VECTOR-PUT-PREDICATING in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MEMBER16-VECTOR-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MEMBER16-VECTOR-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MEMBER16-VECTOR-PUT-PREDICATING in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MEMBER8-VECTOR-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MEMBER8-VECTOR-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MEMBER8-VECTOR-PUT-PREDICATING in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::BOOLE-CONSTANT-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::BOOLE-CONSTANT-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::BOOLE-CONSTANT-PUT-PREDICATING in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::NULL-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::NULL-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::PAD8-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::PAD8-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::PAD16-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::PAD16-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::PAD32-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::PAD32-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::BIT-VECTOR256-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::BIT-VECTOR256-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::STRING-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::STRING-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::SEQUENCE-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::SEQUENCE-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CLIENT-MESSAGE-EVENT-GET-SEQUENCE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CLIENT-MESSAGE-EVENT-PUT-SEQUENCE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CLIENT-MESSAGE-SEQUENCE-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CLIENT-MESSAGE-SEQUENCE-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CODE-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CODE-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CODE-PUT-PREDICATING in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::LENGTH-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::LENGTH-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::LENGTH-PUT-PREDICATING in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DATA-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DATA-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DATA-PUT-PREDICATING in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::OR-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::OR-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::PROGN-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::PROGN-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::CHECK-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITH-BUFFER-REQUEST-INTERNAL in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITH-BUFFER-REQUEST in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITH-BUFFER-REQUEST-AND-REPLY in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::COMPARE-REQUEST in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::PUT-ITEMS in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DECODE-TYPE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::ENCODE-TYPE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::SET-DECODE-TYPE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::THREADED-ATOMIC-PUSH in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::THREADED-ATOMIC-POP in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::THREADED-NCONC in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::THREADED-PUSH in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::THREADED-POP in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::THREADED-ENQUEUE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::THREADED-DEQUEUE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::THREADED-REQUEUE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::THREADED-DOLIST in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::THREADED-DELETE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::THREADED-LENGTH in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/bufmac.lisp" (written 05 FEB 2026 08:57:08 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/bufmac-tmpOHM494YR.fasl
; compilation finished in 0:00:00.075
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WRITE-CARD8 in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WRITE-INT8 in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WRITE-CARD16 in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WRITE-INT16 in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WRITE-CARD32 in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WRITE-INT32 in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WRITE-CARD29 in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WRITE-CHAR2B in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::SET-BUFFER-OFFSET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::ADVANCE-BUFFER-OFFSET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITH-BUFFER-OUTPUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WRITING-BUFFER-CHUNKS in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/buffer.lisp" (written 05 FEB 2026 08:57:08 AM):
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

; file: /usr/share/common-lisp/source/clx/buffer.lisp
; in: DEFUN READ-VECTOR-CARD8
;     (AREF XLIB::DATA XLIB::J)
; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

; in: DEFUN READ-VECTOR-CARD8-WITH-TRANSFORM
;     (AREF XLIB::DATA XLIB::J)
; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

; in: DEFUN READ-VECTOR-CARD16
;     (AREF XLIB::DATA XLIB::J)
; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

; in: DEFUN READ-VECTOR-CARD16-WITH-TRANSFORM
;     (AREF XLIB::DATA XLIB::J)
; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

; in: DEFUN READ-VECTOR-CARD32
;     (AREF XLIB::DATA XLIB::J)
; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

; in: DEFUN READ-VECTOR-CARD32-WITH-TRANSFORM
;     (AREF XLIB::DATA XLIB::J)
; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

; in: DEFUN WRITE-VECTOR-CARD8
;     (AREF XLIB::DATA XLIB::INDEX)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

; in: DEFUN WRITE-VECTOR-CARD8-WITH-TRANSFORM
;     (AREF XLIB::DATA XLIB::INDEX)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

; in: DEFUN WRITE-VECTOR-CARD16
;     (AREF XLIB::DATA XLIB::INDEX)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

; in: DEFUN WRITE-VECTOR-CARD16-WITH-TRANSFORM
;     (AREF XLIB::DATA XLIB::INDEX)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

; in: DEFUN WRITE-VECTOR-INT16
;     (AREF XLIB::DATA XLIB::INDEX)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

; in: DEFUN WRITE-VECTOR-INT16-WITH-TRANSFORM
;     (AREF XLIB::DATA XLIB::INDEX)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

; in: DEFUN WRITE-VECTOR-CARD32
;     (AREF XLIB::DATA XLIB::INDEX)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

; in: DEFUN WRITE-VECTOR-CARD32-WITH-TRANSFORM
;     (AREF XLIB::DATA XLIB::INDEX)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

; in: DEFUN WRITE-VECTOR-CHAR2B
;     (AREF XLIB::DATA XLIB::INDEX)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

; in: DEFUN WRITE-VECTOR-CHAR2B-WITH-TRANSFORM
;     (AREF XLIB::DATA XLIB::INDEX)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/buffer-tmpOVFB07XF.fasl
; compilation finished in 0:00:01.540
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITH-BUFFER in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::READ-CARD8 in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::READ-INT8 in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::READ-CARD16 in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::READ-INT16 in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::READ-CARD32 in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::READ-INT32 in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::READ-CARD29 in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::EVENT-CODE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::READING-EVENT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITH-BUFFER-INPUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITH-BUFFER-FLUSH-INHIBITED in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DEFINE-TRANSFORMED-SEQUENCE-READER in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DEFINE-LIST-READERS in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DEFINE-SEQUENCE-READER in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DEFINE-TRANSFORMED-SEQUENCE-WRITER in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DEFINE-LIST-WRITERS in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DEFINE-SEQUENCE-WRITER in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/display.lisp" (written 05 FEB 2026 08:57:08 AM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

; 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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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 /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/display-tmpG6VFGMYP.fasl
; compilation finished in 0:00:00.583
REDEFINITION-WITH-DEFMACRO: redefining XLIB:WITH-DISPLAY in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::ALLOCATE-RESOURCE-ID in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DEALLOCATE-RESOURCE-ID in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB:WITH-EVENT-QUEUE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITH-EVENT-QUEUE-INTERNAL in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/gcontext.lisp" (written 05 FEB 2026 08:57:08 AM):
CODE-DELETION-NOTE: deleting unreachable code
CODE-DELETION-NOTE: deleting unreachable code

; file: /usr/share/common-lisp/source/clx/gcontext.lisp
; in: DEFUN SET-GCONTEXT-DASHES
;     (VECTOR)
; 
; note: deleting unreachable code
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

; 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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR VECTOR
                                                    SB-KERNEL:EXTENDED-SEQUENCE
                                                    CONS), not a VECTOR.

;     (LENGTH XLIB::LOCAL-DASH)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR VECTOR SB-KERNEL:EXTENDED-SEQUENCE
;                               CONS), not a VECTOR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR VECTOR
                                                    SB-KERNEL:EXTENDED-SEQUENCE
                                                    CONS), 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 VECTOR SB-KERNEL:EXTENDED-SEQUENCE
;                               CONS), not a VECTOR.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a SINGLE-FLOAT.
                        The second argument is a T, not a SINGLE-FLOAT.

;     (EQL (SVREF XLIB::SERVER-STATE XLIB::I)
;          (SETQ XLIB::LOCAL (SVREF XLIB::LOCAL-STATE XLIB::I)))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a SINGLE-FLOAT.
;   The second argument is a T, not a SINGLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a DOUBLE-FLOAT.
                        The second argument is a T, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a DOUBLE-FLOAT.
;   The second argument is a T, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        callable expression is not known to be a function

;     (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
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline (unsigned-byte 64) comparison (cost 6) because:
      The first argument is a T, not a (UNSIGNED-BYTE 64).
      The second argument is a T, not a (UNSIGNED-BYTE 64).
      unable to do inline (signed-byte 64) comparison (cost 6) because:
      The first argument is a T, not a (SIGNED-BYTE 64).
      The second argument is a T, not a (SIGNED-BYTE 64).

;     (EQL (SVREF XLIB::SERVER-STATE XLIB::I)
;          (SETQ XLIB::LOCAL (SVREF XLIB::LOCAL-STATE XLIB::I)))
; 
; note: forced to do full call
;       unable to do inline (unsigned-byte 64) comparison (cost 6) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       unable to do inline (signed-byte 64) comparison (cost 6) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The second argument is a T, not a (SIGNED-BYTE 64).
SIMPLE-COMPILER-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-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
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a SIMPLE-ARRAY.

;     (ELT XLIB::*GCONTEXT-EXTENSIONS* XLIB::I)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-ARRAY.
SIMPLE-COMPILER-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 LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        callable expression is not known to be a function

;     (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
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 1) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &OPTIONAL).
      etc.

;     (- XLIB::*GCONTEXT-DATA-LENGTH*)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline ASH (cost 2) because:
      The first argument is a UNSIGNED-BYTE, not a FIXNUM.
      The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
                                                                      &OPTIONAL).
      unable to do inline ASH (cost 3) because:
      The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
      The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
                                                               (UNSIGNED-BYTE
                                                                64)
                                                               &OPTIONAL).
      etc.

;     (ASH XLIB::EXTENSION-MASK (- XLIB::*GCONTEXT-DATA-LENGTH*))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        callable expression is not known to be a function

; in: DEFUN RESTORE-GCONTEXT-TEMP-STATE
;     (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
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a T, not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline float arithmetic (cost 1) because:
      The first argument is a T, not a SINGLE-FLOAT.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
                                                               &OPTIONAL).
      etc.

;     (- XLIB::*GCONTEXT-DATA-LENGTH*)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline ASH (cost 2) because:
      The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
                                                                      &OPTIONAL).
      unable to do inline ASH (cost 3) because:
      The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
                                                               (UNSIGNED-BYTE
                                                                64)
                                                               &OPTIONAL).
      etc.

;     (ASH XLIB::TEMP-MASK (- XLIB::*GCONTEXT-DATA-LENGTH*))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        callable expression is not known to be a function

; 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
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a SEQUENCE, not a (OR LIST
                                                                     VECTOR).

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

;     (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
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a SEQUENCE, not a (OR LIST
                                                                     VECTOR).

;     (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 /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/gcontext-tmp4QIPRMOF.fasl
; compilation finished in 0:00:02.051
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-FUNCTION in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-PLANE-MASK in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-FOREGROUND in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-BACKGROUND in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-LINE-WIDTH in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-LINE-STYLE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-CAP-STYLE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-JOIN-STYLE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-FILL-STYLE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-FILL-RULE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-TILE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-STIPPLE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-TS-X in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-TS-Y in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-FONT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-SUBWINDOW-MODE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-EXPOSURES in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-CLIP-X in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-CLIP-Y in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-CLIP-MASK in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-DASH-OFFSET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-DASHES in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-ARC-MODE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-CLIP in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-DASH in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-FONT-OBJ in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-INTERNAL-TIMESTAMP in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GCONTEXT-STATE-NEXT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::XGCMASK->GCMASK in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::ACCESS-GCONTEXT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::MODIFY-GCONTEXT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DEF-GC-ACCESSOR in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::INCF-INTERNAL-TIMESTAMP in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB:WITH-GCONTEXT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB:DEFINE-GCONTEXT-ACCESSOR in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/input.lisp" (written 05 FEB 2026 08:57:08 AM):
CODE-DELETION-NOTE: deleting unreachable code
CODE-DELETION-NOTE: deleting unreachable code

; file: /usr/share/common-lisp/source/clx/input.lisp
; in: DEFUN READ-INPUT
;     (CONS NIL NIL)
; 
; note: deleting unreachable code
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        callable expression is not known to be a function

; 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
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      because:
                        Upgraded element type of array is not known at compile time.

; 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
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-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
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      because:
                        Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-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
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      because:
                        Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-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
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-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 COND IF 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.
SIMPLE-COMPILER-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 COND IF IF 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.
SIMPLE-COMPILER-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 COND IF IF IF 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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        callable expression is not known to be a function

; 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 /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/input-tmpGW0QV22K.fasl
; compilation finished in 0:00:02.940
REDEFINITION-WITH-DEFMACRO: redefining XLIB:DEFINE-EXTENSION in DEFMACRO
REDEFINITION-WITH-DEFUN: redefining XLIB::CANONICALIZE-EVENT-NAME in DEFUN
REDEFINITION-WITH-DEFUN: redefining XLIB::EXTENSION-EVENT-KEY-P in DEFUN
REDEFINITION-WITH-DEFUN: redefining XLIB::ALLOCATE-EXTENSION-EVENT-CODE in DEFUN
REDEFINITION-WITH-DEFMACRO: redefining XLIB:EXTENSION-OPCODE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DEFINE-EVENT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB:DECLARE-EVENT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::EVENT-LOOP in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB:EVENT-CASE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB:EVENT-COND in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::EVENT-DISPATCH in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::BINDING-EVENT-VALUES in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB:DEFINE-ERROR in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/requests.lisp" (written 05 FEB 2026 08:57:08 AM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        callable expression is not known to be a function

; 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
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a (VALUES (OR (INTEGER * -1) (INTEGER 4096)) &OPTIONAL), not a (VALUES
                                                                                    FIXNUM
                                                                                    &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
      The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES (OR (INTEGER * -1) (INTEGER 4096)) &OPTIONAL), not a (VALUES
                                                                                    (UNSIGNED-BYTE
                                                                                     64)
                                                                                    &OPTIONAL).
      etc.

;     (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 
; ==>
;   (LOGIOR XLIB::%MASK 4096)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -1) (INTEGER 4096)) &OPTIONAL), not a (VALUES
;                                                                                     FIXNUM
;                                                                                     &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (OR (INTEGER * -1) (INTEGER 4096)) &OPTIONAL), not a (VALUES
;                                                                                     (UNSIGNED-BYTE
;                                                                                      64)
;                                                                                     &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a (VALUES (OR (INTEGER * -1) (INTEGER 8192)) &OPTIONAL), not a (VALUES
                                                                                    FIXNUM
                                                                                    &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
      The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES (OR (INTEGER * -1) (INTEGER 8192)) &OPTIONAL), not a (VALUES
                                                                                    (UNSIGNED-BYTE
                                                                                     64)
                                                                                    &OPTIONAL).
      etc.

; ==>
;   (LOGIOR XLIB::%MASK 8192)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -1) (INTEGER 8192)) &OPTIONAL), not a (VALUES
;                                                                                     FIXNUM
;                                                                                     &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (OR (INTEGER * -1) (INTEGER 8192)) &OPTIONAL), not a (VALUES
;                                                                                     (UNSIGNED-BYTE
;                                                                                      64)
;                                                                                     &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a (VALUES (OR (INTEGER * -1) (INTEGER 16384)) &OPTIONAL), not a (VALUES
                                                                                     FIXNUM
                                                                                     &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
      The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
      The result is a (VALUES (OR (INTEGER * -1) (INTEGER 16384)) &OPTIONAL), not a (VALUES
                                                                                     (UNSIGNED-BYTE
                                                                                      64)
                                                                                     &OPTIONAL).
      etc.

; ==>
;   (LOGIOR XLIB::%MASK 16384)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -1) (INTEGER 16384)) &OPTIONAL), not a (VALUES
;                                                                                      FIXNUM
;                                                                                      &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (OR (INTEGER * -1) (INTEGER 16384)) &OPTIONAL), not a (VALUES
;                                                                                      (UNSIGNED-BYTE
;                                                                                       64)
;                                                                                      &OPTIONAL).
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        callable expression is not known to be a function

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

; 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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR LIST (SIMPLE-ARRAY * (*))
                                                    SB-KERNEL:EXTENDED-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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS
                                                    SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
                                                                                         *
                                                                                         (*)).

;     (ELT SEQUENCE XLIB::I)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
;                                                                    * (*)).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS
                                                    SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        callable expression is not known to be a function

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

; in: DEFUN SET-POINTER-MAPPING
;     (LENGTH MAP)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The result is a (VALUES (RATIONAL 0 65535)
                                                &OPTIONAL), not a (VALUES
                                                                   INTEGER
                                                                   &REST T).

; in: DEFUN POINTER-CONTROL
;     (/ (XLIB::CARD16-GET 8) (XLIB::CARD16-GET 10))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The result is a (VALUES (RATIONAL 0 65535) &OPTIONAL), not a (VALUES INTEGER
;                                                                        &REST T).
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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
                                                                                         *
                                                                                         (*)).

; in: DEFUN ACCESS-HOSTS
;     (ELT SEQUENCE XLIB::I)
; 
; 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
;                                                                    * (*)).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR LIST (SIMPLE-ARRAY * (*))
                                                    SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
; 
; 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 /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/requests-tmp2K9J0HSR.fasl
; compilation finished in 0:00:03.764
REDEFINITION-WITH-DEFMACRO: redefining XLIB:WITH-SERVER-GRABBED in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/fonts.lisp" (written 05 FEB 2026 08:57:08 AM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        callable expression is not known to be a function

; 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
SIMPLE-COMPILER-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
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a SINGLE-FLOAT.

; 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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
SIMPLE-COMPILER-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 division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a SIMPLE-ARRAY.

;     (ELT XLIB::PATHS XLIB::I)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-ARRAY.
SIMPLE-COMPILER-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 LIST.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR STRING SYMBOL
                                                    CHARACTER), not a (OR
                                                                       STRING
                                                                       SYMBOL).

;     (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 (OR STRING
;                                                                   SYMBOL).
SIMPLE-COMPILER-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 SYMBOL.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (OR STRING SYMBOL
                                                    CHARACTER), not a STRING.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR STRING SYMBOL CHARACTER), not a STRING.


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/fonts-tmpP44I4E0Y.fasl
; compilation finished in 0:00:00.494
; compiling file "/usr/share/common-lisp/source/clx/graphics.lisp" (written 05 FEB 2026 08:57:08 AM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

; 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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

; in: DEFUN DRAW-ARCS-VECTOR
;     (AREF XLIB::ARCS (XLIB::INDEX+ XLIB::N 0))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

;     (AREF XLIB::ARCS (XLIB::INDEX+ XLIB::N 1))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

;     (AREF XLIB::ARCS (XLIB::INDEX+ XLIB::N 2))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

;     (AREF XLIB::ARCS (XLIB::INDEX+ XLIB::N 3))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

;     (AREF XLIB::ARCS (XLIB::INDEX+ XLIB::N 4))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        avoid runtime dispatch on array element type
                      because:
                        Upgraded element type of array is not known at compile time.

;     (AREF XLIB::ARCS (XLIB::INDEX+ XLIB::N 5))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      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-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

; 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 /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/graphics-tmp63LQ7EX6.fasl
; compilation finished in 0:00:00.881
; compiling file "/usr/share/common-lisp/source/clx/text.lisp" (written 05 FEB 2026 08:57:08 AM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

; 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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
      unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a T, not a FIXNUM.
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      etc.

; in: DEFUN DRAW-GLYPH
;     (LDB (BYTE 8 0) ELT)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       etc.
SIMPLE-COMPILER-NOTE: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
      unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a T, not a FIXNUM.
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a T, not a FIXNUM.
      etc.

; in: DEFUN DRAW-IMAGE-GLYPH
;     (LDB (BYTE 8 0) ELT)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       etc.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (ARRAY *
                                                 (* *)), not a SIMPLE-ARRAY.

; in: DEFUN CHANGE-KEYBOARD-MAPPING
;     (AREF XLIB::KEYSYMS XLIB::I XLIB::J)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (ARRAY *
                                                 (* *)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-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
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a NUMBER, not a RATIONAL.

; in: DEFUN KEYBOARD-MAPPING
;     (1+ XLIB::I)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (ARRAY *
                                                 (* *)), not a SIMPLE-ARRAY.

;     (AREF XLIB::RESULT XLIB::I XLIB::J)
; --> FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a (ARRAY *
                                                 (* *)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (ARRAY * (* *)), not a SIMPLE-ARRAY.
SIMPLE-COMPILER-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
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
SIMPLE-COMPILER-NOTE: forced to do full call
      unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a (OR NUMBER NULL), not a FIXNUM.
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
      unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
      The first argument is a (OR NUMBER NULL), not a (UNSIGNED-BYTE 64).
      The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
                                                        (UNSIGNED-BYTE 64)
                                                        &OPTIONAL).
      etc.

;     (1+ XLIB::I)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR NUMBER NULL), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 5) because:
;       The first argument is a (OR NUMBER NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/text-tmp86F1A8FB.fasl
; compilation finished in 0:00:01.198
; compiling file "/usr/share/common-lisp/source/clx/attributes.lisp" (written 05 FEB 2026 08:57:08 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/attributes-tmpH7D4HL98.fasl
; compilation finished in 0:00:00.671
REDEFINITION-WITH-DEFMACRO: redefining XLIB::STATE-ATTRIBUTES in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::STATE-ATTRIBUTE-CHANGES in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::STATE-GEOMETRY in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::STATE-GEOMETRY-CHANGES in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DRAWABLE-EQUAL-FUNCTION in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WINDOW-EQUAL-FUNCTION in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB:WITH-STATE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITH-ATTRIBUTES in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITH-GEOMETRY in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/translate.lisp" (written 05 FEB 2026 08:57:08 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/translate-tmpCDM7YXYI.fasl
; compilation finished in 0:00:00.259
REDEFINITION-WITH-DEFMACRO: redefining XLIB:KEYSYM in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::KEYSYM-MAPPING-OBJECT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::KEYSYM-MAPPING-TRANSLATE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::KEYSYM-MAPPING-LOWERCASE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::KEYSYM-MAPPING-MODIFIERS in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::KEYSYM-MAPPING-MASK in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/keysyms.lisp" (written 05 FEB 2026 08:57:08 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/keysyms-tmpLM57P5P.fasl
; compilation finished in 0:00:00.029
; compiling file "/usr/share/common-lisp/source/clx/manager.lisp" (written 05 FEB 2026 08:57:08 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/manager-tmpZE69DN33.fasl
; compilation finished in 0:00:01.636
; compiling file "/usr/share/common-lisp/source/clx/image.lisp" (written 05 FEB 2026 08:57:08 AM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The second argument is a SEQUENCE, not a (OR LIST
                                                                     VECTOR).

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


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/image-tmpG8099TO3.fasl
; compilation finished in 0:00:03.032
REDEFINITION-WITH-DEFMACRO: redefining XLIB::WITH-IMAGE-DATA-BUFFER in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB:IMAGE-NAME in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB:IMAGE-X-HOT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB:IMAGE-Y-HOT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB:IMAGE-RED-MASK in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB:IMAGE-BLUE-MASK in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB:IMAGE-GREEN-MASK in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/resource.lisp" (written 05 FEB 2026 08:57:08 AM):
CODE-DELETION-NOTE: deleting unreachable code
CODE-DELETION-NOTE: deleting unreachable code

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


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/resource-tmpTASQCYAW.fasl
; compilation finished in 0:00:00.559
REDEFINITION-WITH-DEFMACRO: redefining XLIB::RESOURCE-WITH-OPEN-FILE in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/extensions/shape.lisp" (written 05 FEB 2026 08:57:08 AM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

; 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 /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/extensions/shape-tmp35U57IV6.fasl
; compilation finished in 0:00:00.370
; compiling file "/usr/share/common-lisp/source/clx/extensions/big-requests.lisp" (written 05 FEB 2026 08:57:08 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/extensions/big-requests-tmpTZOONXRW.fasl
; compilation finished in 0:00:00.018
; compiling file "/usr/share/common-lisp/source/clx/extensions/xvidmode.lisp" (written 05 FEB 2026 08:57:08 AM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The result is a (VALUES (RATIONAL 0 13107/20)
                                                &OPTIONAL), not a (VALUES
                                                                   INTEGER
                                                                   &REST T).

; file: /usr/share/common-lisp/source/clx/extensions/xvidmode.lisp
; in: DEFUN XFREE86-VIDMODE-GET-MONITOR
;     (/ (LDB (BYTE 16 0) XLIB::I) 100)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The result is a (VALUES (RATIONAL 0 13107/20) &OPTIONAL), not a (VALUES
;                                                                    INTEGER
;                                                                    &REST T).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The result is a (VALUES (RATIONAL 0 13107/20)
                                                &OPTIONAL), not a (VALUES
                                                                   INTEGER
                                                                   &REST T).

;     (/ (LDB (BYTE 32 16) XLIB::I) 100)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The result is a (VALUES (RATIONAL 0 13107/20) &OPTIONAL), not a (VALUES
;                                                                    INTEGER
;                                                                    &REST T).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The result is a (VALUES (RATIONAL 0 13107/20)
                                                &OPTIONAL), not a (VALUES
                                                                   INTEGER
                                                                   &REST T).

;     (/ (LDB (BYTE 16 0) XLIB::I) 100)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The result is a (VALUES (RATIONAL 0 13107/20) &OPTIONAL), not a (VALUES
;                                                                    INTEGER
;                                                                    &REST T).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The result is a (VALUES (RATIONAL 0 13107/20)
                                                &OPTIONAL), not a (VALUES
                                                                   INTEGER
                                                                   &REST T).

;     (/ (LDB (BYTE 32 16) XLIB::I) 100)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The result is a (VALUES (RATIONAL 0 13107/20) &OPTIONAL), not a (VALUES
;                                                                    INTEGER
;                                                                    &REST T).


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/extensions/xvidmode-tmpWN0UKDSV.fasl
; compilation finished in 0:00:01.196
REDEFINITION-WITH-DEFMACRO: redefining XLIB::VIDMODE-OPCODE in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/extensions/xrender.lisp" (written 05 FEB 2026 08:57:08 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/extensions/xrender-tmpBF3HHBTQ.fasl
; compilation finished in 0:00:03.091
REDEFINITION-WITH-DEFMACRO: redefining XLIB::PICTURE-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::PICTURE-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GLYPH-SET-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::GLYPH-SET-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::PICTURE-FORMAT-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::PICTURE-FORMAT-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::RENDER-OP-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::RENDER-OP-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::%RENDER-COMPOSITE-GLYPHS in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/extensions/glx.lisp" (written 05 FEB 2026 08:57:08 AM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        callable expression is not known to be a function

; file: /usr/share/common-lisp/source/clx/extensions/glx.lisp
; 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


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/extensions/glx-tmpGYUNPZCY.fasl
; compilation finished in 0:00:00.740
; compiling file "/usr/share/common-lisp/source/clx/extensions/gl.lisp" (written 05 FEB 2026 08:57:08 AM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a SEQUENCE, not a VECTOR.

; 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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY SETF SETQ THE 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY SETF SETQ THE 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY SETF SETQ THE 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY SETF SETQ THE 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY SETF SETQ THE 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY SETF SETQ THE 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY SETF SETQ THE 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY SETF SETQ THE 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-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.
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> ASSERT TAGBODY SETF SETQ THE 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND COLOR-TABLE-PARAMETER-FV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::COLOR-TABLE-PARAMETER-FV 2054
;                                        (XLIB/GL::TARGET XLIB:CARD32)
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAMS
;                                         (LIST XLIB/GL::FLOAT32 4)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND COLOR-TABLE-PARAMETER-IV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::COLOR-TABLE-PARAMETER-IV 2055
;                                        (XLIB/GL::TARGET XLIB:CARD32)
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAMS (LIST XLIB:INT32 4)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND CONVOLUTION-PARAMETER-FV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::CONVOLUTION-PARAMETER-FV 4104
;                                        (XLIB/GL::TARGET XLIB:CARD32)
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAMS
;                                         (LIST XLIB/GL::FLOAT32
;                                               (ECASE XLIB/GL::PNAME
;                                                 (# 1)
;                                                 (# 4)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND CONVOLUTION-PARAMETER-IV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::CONVOLUTION-PARAMETER-IV 4106
;                                        (XLIB/GL::TARGET XLIB:CARD32)
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAMS
;                                         (LIST XLIB:INT32
;                                               (ECASE XLIB/GL::PNAME
;                                                 (# 1)
;                                                 (# 4)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND FOG-FV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::FOG-FV 81
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAMS
;                                         (LIST XLIB/GL::FLOAT32
;                                               (ECASE XLIB/GL::PNAME
;                                                 (# 1)
;                                                 (# 4)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND FOG-IV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::FOG-IV 83
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAMS
;                                         (LIST XLIB:INT32
;                                               (ECASE XLIB/GL::PNAME
;                                                 (# 1)
;                                                 (# 4)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND LIGHT-MODEL-FV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::LIGHT-MODEL-FV 91
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAMS
;                                         (LIST XLIB/GL::FLOAT32
;                                               (ECASE XLIB/GL::PNAME
;                                                 (# 1)
;                                                 (# 4)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND LIGHT-MODEL-IV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::LIGHT-MODEL-IV 93
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAMS
;                                         (LIST XLIB:INT32
;                                               (ECASE XLIB/GL::PNAME
;                                                 (# 1)
;                                                 (# 4)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND LIGHT-FV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL:LIGHT-FV 87
;                                        (XLIB/GL::LIGHT XLIB:CARD32)
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAMS
;                                         (LIST XLIB/GL::FLOAT32
;                                               (ECASE XLIB/GL::PNAME
;                                                 (# 4)
;                                                 (# 3)
;                                                 (# 1)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND LIGHT-IV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL:LIGHT-IV 89
;                                        (XLIB/GL::LIGHT XLIB:CARD32)
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAMS
;                                         (LIST XLIB:INT32
;                                               (ECASE XLIB/GL::PNAME
;                                                 (# 4)
;                                                 (# 3)
;                                                 (# 1)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND LOAD-MATRIX-D
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::LOAD-MATRIX-D 178
;                                        (XLIB/GL::M (LIST XLIB/GL::FLOAT64 16)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND LOAD-MATRIX-F
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::LOAD-MATRIX-F 177
;                                        (XLIB/GL::M (LIST XLIB/GL::FLOAT32 16)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND MATERIAL-FV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL:MATERIAL-FV 97
;                                        (XLIB/GL::FACE XLIB:CARD32)
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAMS
;                                         (LIST XLIB/GL::FLOAT32
;                                               (ECASE XLIB/GL::PNAME
;                                                 (# 4)
;                                                 (# 1)
;                                                 (# 3)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND MATERIAL-IV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL:MATERIAL-IV 99
;                                        (XLIB/GL::FACE XLIB:CARD32)
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAMS
;                                         (LIST XLIB:INT32
;                                               (ECASE XLIB/GL::PNAME
;                                                 (# 4)
;                                                 (# 1)
;                                                 (# 3)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND MULT-MATRIX-D
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::MULT-MATRIX-D 181
;                                        (XLIB/GL::M (LIST XLIB/GL::FLOAT64 16)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND MULT-MATRIX-F
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::MULT-MATRIX-F 180
;                                        (XLIB/GL::M (LIST XLIB/GL::FLOAT32 16)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND PRIORITIZE-TEXTURES
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::PRIORITIZE-TEXTURES 4118
;                                        (XLIB/GL::N XLIB:INT32)
;                                        (XLIB/GL::TEXTURES
;                                         (LIST XLIB:CARD32 XLIB/GL::N))
;                                        (XLIB/GL::PRIORITIES
;                                         (LIST XLIB/GL::FLOAT32 XLIB/GL::N)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND TEX-ENV-FV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::TEX-ENV-FV 112
;                                        (XLIB/GL::TARGET XLIB:CARD32)
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAM
;                                         (LIST XLIB/GL::FLOAT32
;                                               (ECASE XLIB/GL::PNAME
;                                                 (8704 1)
;                                                 (8705 4)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND TEX-ENV-IV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::TEX-ENV-IV 114
;                                        (XLIB/GL::TARGET XLIB:CARD32)
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAM
;                                         (LIST XLIB:INT32
;                                               (ECASE XLIB/GL::PNAME
;                                                 (8704 1)
;                                                 (8705 4)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND TEX-GEN-DV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::TEX-GEN-DV 116
;                                        (XLIB/GL::COORD XLIB:CARD32)
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAMS
;                                         (LIST XLIB/GL::FLOAT64
;                                               (ECASE XLIB/GL::PNAME
;                                                 (# 1)
;                                                 (9473 4)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND TEX-GEN-FV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::TEX-GEN-FV 118
;                                        (XLIB/GL::COORD XLIB:CARD32)
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAMS
;                                         (LIST XLIB/GL::FLOAT32
;                                               (ECASE XLIB/GL::PNAME
;                                                 (# 1)
;                                                 (9473 4)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND TEX-GEN-IV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::TEX-GEN-IV 120
;                                        (XLIB/GL::COORD XLIB:CARD32)
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAMS
;                                         (LIST XLIB:INT32
;                                               (ECASE XLIB/GL::PNAME
;                                                 (# 1)
;                                                 (9473 4)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND TEX-PARAMETER-FV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::TEX-PARAMETER-FV 106
;                                        (XLIB/GL::TARGET XLIB:CARD32)
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAMS
;                                         (LIST XLIB/GL::FLOAT32
;                                               (ECASE XLIB/GL::PNAME
;                                                 (# 4)
;                                                 (# 1)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The first argument is a T, not a (NOT
                                                          SB-KERNEL:EXTENDED-SEQUENCE).

; in: DEFINE-RENDERING-COMMAND TEX-PARAMETER-IV
;     (XLIB/GL::DEFINE-RENDERING-COMMAND XLIB/GL::TEX-PARAMETER-IV 108
;                                        (XLIB/GL::TARGET XLIB:CARD32)
;                                        (XLIB/GL::PNAME XLIB:CARD32)
;                                        (XLIB/GL::PARAMS
;                                         (LIST XLIB:INT32
;                                               (ECASE XLIB/GL::PNAME
;                                                 (# 4)
;                                                 (# 1)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a T, not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/extensions/gl-tmpD68Q8WCA.fasl
; compilation finished in 0:00:04.027
REDEFINITION-WITH-DEFUN: redefining XLIB/GL::BYTE-WIDTH in DEFUN
REDEFINITION-WITH-DEFUN: redefining XLIB/GL::SETTER in DEFUN
REDEFINITION-WITH-DEFUN: redefining XLIB/GL::SEQUENCE-SETTER in DEFUN
REDEFINITION-WITH-DEFMACRO: redefining XLIB/GL::DEFINE-SEQUENCE-SETTER in DEFMACRO
REDEFINITION-WITH-DEFUN: redefining XLIB/GL::SSET-INT8 in DEFUN
REDEFINITION-WITH-DEFUN: redefining XLIB/GL::SSET-INT16 in DEFUN
REDEFINITION-WITH-DEFUN: redefining XLIB/GL::SSET-INT32 in DEFUN
REDEFINITION-WITH-DEFUN: redefining XLIB/GL::SSET-BOOL in DEFUN
REDEFINITION-WITH-DEFUN: redefining XLIB/GL::SSET-CARD8 in DEFUN
REDEFINITION-WITH-DEFUN: redefining XLIB/GL::SSET-CARD16 in DEFUN
REDEFINITION-WITH-DEFUN: redefining XLIB/GL::SSET-CARD32 in DEFUN
REDEFINITION-WITH-DEFUN: redefining XLIB/GL::SSET-FLOAT32 in DEFUN
REDEFINITION-WITH-DEFUN: redefining XLIB/GL::SSET-FLOAT64 in DEFUN
REDEFINITION-WITH-DEFUN: redefining XLIB/GL::MAKE-ARGSPECS in DEFUN
REDEFINITION-WITH-DEFUN: redefining XLIB/GL::BYTE-WIDTH-CALCULATION in DEFUN
REDEFINITION-WITH-DEFUN: redefining XLIB/GL::COMPOSITE-ARGS in DEFUN
REDEFINITION-WITH-DEFUN: redefining XLIB/GL::MAKE-SETTER-FORMS in DEFUN
REDEFINITION-WITH-DEFMACRO: redefining XLIB/GL::DEFINE-RENDERING-COMMAND in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/extensions/dpms.lisp" (written 05 FEB 2026 08:57:08 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/extensions/dpms-tmp7MK9KM9C.fasl
; compilation finished in 0:00:00.767
REDEFINITION-WITH-DEFMACRO: redefining XLIB/DPMS::DPMS-OPCODE in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/extensions/xtest.lisp" (written 05 FEB 2026 08:57:08 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/extensions/xtest-tmpJJ71X849.fasl
; compilation finished in 0:00:00.174
REDEFINITION-WITH-DEFMACRO: redefining XLIB/XTEST::OPCODE in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/extensions/screensaver.lisp" (written 05 FEB 2026 08:57:08 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/extensions/screensaver-tmp1VUK6SR2.fasl
; compilation finished in 0:00:00.047
; compiling file "/usr/share/common-lisp/source/clx/extensions/randr.lisp" (written 05 FEB 2026 08:57:08 AM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize
                      due to type uncertainty:
                        The result is a (VALUES (RATIONAL 0 4294967295)
                                                &OPTIONAL), not a (VALUES
                                                                   INTEGER
                                                                   &REST T).

; file: /usr/share/common-lisp/source/clx/extensions/randr.lisp
; in: DEFUN RR-GET-OUTPUT-PROPERTY
;     (/ XLIB::BYTES-AFTER XLIB::VALUE-LENGTH)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The result is a (VALUES (RATIONAL 0 4294967295) &OPTIONAL), not a (VALUES
;                                                                      INTEGER
;                                                                      &REST T).


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/extensions/randr-tmpR2FIHSUG.fasl
; compilation finished in 0:00:02.221
REDEFINITION-WITH-DEFMACRO: redefining XLIB::DEFINE-MASK-FNS in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::RR-TRANSFORM-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::RR-TRANSFORM-PUT in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::RR-MODE-INFO-GET in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining XLIB::RR-MODE-INFO-PUT in DEFMACRO
; compiling file "/usr/share/common-lisp/source/clx/extensions/xinerama.lisp" (written 05 FEB 2026 08:57:08 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/extensions/xinerama-tmp8PYELRKX.fasl
; compilation finished in 0:00:00.234
; compiling file "/usr/share/common-lisp/source/clx/extensions/dbe.lisp" (written 05 FEB 2026 08:57:08 AM):
SIMPLE-COMPILER-NOTE: unable to
                        optimize away possible call to FDEFINITION at runtime
                      because:
                        callable expression is not known to be a function

; 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


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/extensions/dbe-tmpEHTOKYT0.fasl
; compilation finished in 0:00:00.258
; compiling file "/usr/share/common-lisp/source/clx/extensions/xc-misc.lisp" (written 05 FEB 2026 08:57:08 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/extensions/xc-misc-tmpS6U1VHI9.fasl
; compilation finished in 0:00:00.052
; compiling file "/usr/share/common-lisp/source/clx/extensions/dri2.lisp" (written 05 FEB 2026 08:57:08 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/extensions/dri2-tmpVTFK6ZJW.fasl
; compilation finished in 0:00:00.359
; compiling file "/usr/share/common-lisp/source/clx/extensions/composite.lisp" (written 05 FEB 2026 08:57:08 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/usr/share/common-lisp/source/clx/extensions/composite-tmp75WVSJEW.fasl
; compilation finished in 0:00:00.147
REDEFINITION-WITH-DEFMACRO: redefining XLIB::COMPOSITE-OPCODE in DEFMACRO
; compiling file "/build/stumpwm/src/stumpwm/dynamic-mixins/src/package.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/dynamic-mixins/src/package-tmpBU5UM3S4.fasl
; compilation finished in 0:00:00.003
; compiling file "/build/stumpwm/src/stumpwm/dynamic-mixins/src/sorting.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/dynamic-mixins/src/sorting-tmpOBHVA3CD.fasl
; compilation finished in 0:00:00.014
; compiling file "/build/stumpwm/src/stumpwm/dynamic-mixins/src/dynamic-mixins.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/dynamic-mixins/src/dynamic-mixins-tmpJ6ELVFLF.fasl
; compilation finished in 0:00:00.069
; compiling file "/build/stumpwm/src/stumpwm/package.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/package-tmpULDB0RG.fasl
; compilation finished in 0:00:00.004
; compiling file "/build/stumpwm/src/stumpwm/debug.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/debug-tmpUTZ0UUTE.fasl
; compilation finished in 0:00:00.027
; compiling file "/build/stumpwm/src/stumpwm/primitives.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/primitives-tmpOOSRA8PZ.fasl
; compilation finished in 0:00:00.806
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM::DEFINE-SWM-CLASS in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:WITH-RESTARTS-MENU in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:ADD-HOOK in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:REMOVE-HOOK in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:REMOVE-ALL-HOOKS in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:DEFINE-FRAME-PREFERENCE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM::DEFINE-FULLSCREEN-IN-FRAME-RULE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM::WITH-FOCUS in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:WITH-DATA-FILE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:MOVE-TO-HEAD in DEFMACRO
; compiling file "/build/stumpwm/src/stumpwm/wrappers.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/wrappers-tmpDMIL0RVK.fasl
; compilation finished in 0:00:00.136
; compiling file "/build/stumpwm/src/stumpwm/pathnames.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/pathnames-tmp8MR9IMIO.fasl
; compilation finished in 0:00:00.010
; compiling file "/build/stumpwm/src/stumpwm/font-rendering.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/font-rendering-tmpJQDKAVAY.fasl
; compilation finished in 0:00:00.053
; compiling file "/build/stumpwm/src/stumpwm/keysyms.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/keysyms-tmp3I8CEEQY.fasl
; compilation finished in 0:00:00.270
; compiling file "/build/stumpwm/src/stumpwm/keytrans.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/keytrans-tmpA3RHFLWZ.fasl
; compilation finished in 0:00:00.023
; compiling file "/build/stumpwm/src/stumpwm/kmap.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/kmap-tmpYZIB7VXO.fasl
; compilation finished in 0:00:00.210
; compiling file "/build/stumpwm/src/stumpwm/input.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/input-tmpR8PK79V8.fasl
; compilation finished in 0:00:00.706
; compiling file "/build/stumpwm/src/stumpwm/core.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/core-tmpN1ZVB1HZ.fasl
; compilation finished in 0:00:00.026
; compiling file "/build/stumpwm/src/stumpwm/command.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/command-tmpZGRRPISB.fasl
; compilation finished in 0:00:00.467
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:DEFCOMMAND in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:DEFINE-STUMPWM-COMMAND in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:DEFCOMMAND-ALIAS in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:DEFINE-STUMPWM-TYPE in DEFMACRO
; compiling file "/build/stumpwm/src/stumpwm/menu-declarations.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/menu-declarations-tmpFNKDE5XP.fasl
; compilation finished in 0:00:00.043
; compiling file "/build/stumpwm/src/stumpwm/menu-definitions.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/menu-definitions-tmpRJTU435C.fasl
; compilation finished in 0:00:00.222
; compiling file "/build/stumpwm/src/stumpwm/screen.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/screen-tmpI9WG87JK.fasl
; compilation finished in 0:00:00.232
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM::SET-ANY-COLOR in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM::WITH-CURRENT-SCREEN in DEFMACRO
; compiling file "/build/stumpwm/src/stumpwm/head.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/head-tmpYDE6I9E6.fasl
; compilation finished in 0:00:00.073
; compiling file "/build/stumpwm/src/stumpwm/group.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/group-tmp319UV2V8.fasl
; compilation finished in 0:00:00.227
; compiling file "/build/stumpwm/src/stumpwm/bindings.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/bindings-tmpLYQINFYS.fasl
; compilation finished in 0:00:00.057
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM::FILL-KEYMAP in DEFMACRO
; compiling file "/build/stumpwm/src/stumpwm/events.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/events-tmpGA31XWNO.fasl
; compilation finished in 0:00:00.434
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM::DEFINE-STUMP-EVENT-HANDLER in DEFMACRO
; compiling file "/build/stumpwm/src/stumpwm/window.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/window-tmp5HT23M6C.fasl
; compilation finished in 0:00:01.162
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:DEFINE-WINDOW-SLOT in DEFMACRO
; compiling file "/build/stumpwm/src/stumpwm/floating-group.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/floating-group-tmpA60KLDKY.fasl
; compilation finished in 0:00:00.453
; compiling file "/build/stumpwm/src/stumpwm/tile-window.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/tile-window-tmpD801X3GJ.fasl
; compilation finished in 0:00:00.202
; compiling file "/build/stumpwm/src/stumpwm/tile-group.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/tile-group-tmpGOW1GC70.fasl
; compilation finished in 0:00:00.787
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:SAVE-FRAME-EXCURSION in DEFMACRO
; compiling file "/build/stumpwm/src/stumpwm/window-placement.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/window-placement-tmpPQ1X28TL.fasl
; compilation finished in 0:00:00.092
; compiling file "/build/stumpwm/src/stumpwm/message-window.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/message-window-tmpE92ECU7O.fasl
; compilation finished in 0:00:00.253
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM::DEFINE-SIMPLE-GRAVITY in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:WITH-MESSAGE-QUEUING in DEFMACRO
; compiling file "/build/stumpwm/src/stumpwm/selection.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/selection-tmp8S0II570.fasl
; compilation finished in 0:00:00.052
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM::MULTISELECT in DEFMACRO
; compiling file "/build/stumpwm/src/stumpwm/module.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/module-tmpJE88A12F.fasl
; compilation finished in 0:00:00.036
; compiling file "/build/stumpwm/src/stumpwm/ioloop.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/ioloop-tmpA5FNLPLT.fasl
; compilation finished in 0:00:00.386
; compiling file "/build/stumpwm/src/stumpwm/timers.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/timers-tmpHKCV9TP8.fasl
; compilation finished in 0:00:00.054
; compiling file "/build/stumpwm/src/stumpwm/stumpwm.lisp" (written 29 AUG 2026 03:46:42 AM):
SIMPLE-STYLE-WARNING: IGNORE declaration for a variable from outer scope: SIGNUM

; file: /build/stumpwm/src/stumpwm/stumpwm.lisp
; in: DEFUN STUMPWM
;     (STUMPWM::SET-SIGNAL-HANDLER SB-POSIX:SIGHUP
;       (STUMPWM:DFORMAT 0
;                        "SIGHUP received: forcing immediate restart of stumpwm~%")
;       (STUMPWM::FORCE-STUMPWM-RESTART))
; --> ALIEN-SAP SB-ALIEN::ALIEN-LAMBDA SB-ALIEN::%ALIEN-CALLBACK-ALIEN 
; --> SB-ALIEN::ALIEN-LAMBDA2 LAMBDA FUNCTION LET LET 
; ==>
;   (LOCALLY
;    (DECLARE (IGNORE SIGNUM))
;    (STUMPWM:DFORMAT 0
;                     "SIGHUP received: forcing immediate restart of stumpwm~%")
;    (STUMPWM::FORCE-STUMPWM-RESTART))
; 
; caught STYLE-WARNING:
;   IGNORE declaration for a variable from outer scope: SIGNUM
SIMPLE-STYLE-WARNING: The variable SIGNUM is defined but never used.

; --> ALIEN-SAP SB-ALIEN::ALIEN-LAMBDA SB-ALIEN::%ALIEN-CALLBACK-ALIEN 
; --> SB-ALIEN::ALIEN-LAMBDA2 LAMBDA FUNCTION LET 
; ==>
;   (LET ((SIGNUM (DEREF (SAP-ALIEN # #))))
;     (LOCALLY
;      (DECLARE (IGNORE SIGNUM))
;      (STUMPWM:DFORMAT 0
;                       "SIGHUP received: forcing immediate restart of stumpwm~%")
;      (STUMPWM::FORCE-STUMPWM-RESTART)))
; 
; caught STYLE-WARNING:
;   The variable SIGNUM is defined but never used.


; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/stumpwm-tmpZ18MA7XE.fasl
; compilation finished in 0:00:00.196
COMPILE-WARNED-WARNING: Lisp compilation had style-warnings while
                        compiling #<CL-SOURCE-FILE "stumpwm" "stumpwm">
WARNING:
   Lisp compilation had style-warnings while
   compiling #<CL-SOURCE-FILE "stumpwm" "stumpwm">
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM::SET-SIGNAL-HANDLER in DEFMACRO
; compiling file "/build/stumpwm/src/stumpwm/user.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/user-tmp6LQJ9T0C.fasl
; compilation finished in 0:00:00.302
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:DEFPROGRAM-SHORTCUT in DEFMACRO
; compiling file "/build/stumpwm/src/stumpwm/interactive-keymap.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/interactive-keymap-tmpTX7OA81T.fasl
; compilation finished in 0:00:00.033
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:DEFINE-INTERACTIVE-KEYMAP in DEFMACRO
; compiling file "/build/stumpwm/src/stumpwm/iresize.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/iresize-tmpWOTC3PB7.fasl
; compilation finished in 0:00:00.036
; compiling file "/build/stumpwm/src/stumpwm/help.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/help-tmpHQE95SAC.fasl
; compilation finished in 0:00:00.287
; compiling file "/build/stumpwm/src/stumpwm/fdump.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/fdump-tmpO87FP9NR.fasl
; compilation finished in 0:00:00.341
; compiling file "/build/stumpwm/src/stumpwm/time.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/time-tmpP6A3E92I.fasl
; compilation finished in 0:00:00.100
; compiling file "/build/stumpwm/src/stumpwm/mode-line.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/mode-line-tmpUSHT8RIL.fasl
; compilation finished in 0:00:00.167
; compiling file "/build/stumpwm/src/stumpwm/mode-line-formatters.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/mode-line-formatters-tmp7YCPD44Y.fasl
; compilation finished in 0:00:00.127
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM::ALTERNATE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM::SCROLL in DEFMACRO
; compiling file "/build/stumpwm/src/stumpwm/color.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/color-tmpQXR7SNXD.fasl
; compilation finished in 0:00:00.299
; compiling file "/build/stumpwm/src/stumpwm/wse.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/wse-tmp6FLI1OC3.fasl
; compilation finished in 0:00:00.050
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:ACT-ON-MATCHING-WINDOWS in DEFMACRO
; compiling file "/build/stumpwm/src/stumpwm/dynamic-window.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/dynamic-window-tmpWBK8JTS9.fasl
; compilation finished in 0:00:00.052
; compiling file "/build/stumpwm/src/stumpwm/dynamic-group.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/dynamic-group-tmpUVEUD2ZN.fasl
; compilation finished in 0:00:00.800
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM::SWAP in DEFMACRO
REDEFINITION-WITH-DEFMETHOD: redefining PRINT-SWM-OBJECT (#<STANDARD-CLASS STUMPWM::DYNAMIC-WINDOW>
                                                          #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM::WITH-GROUP-HEAD-INFO in DEFMACRO
; compiling file "/build/stumpwm/src/stumpwm/remap-keys.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/remap-keys-tmpOWNJOEU.fasl
; compilation finished in 0:00:00.031
; compiling file "/build/stumpwm/src/stumpwm/manual.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/manual-tmpVT5BMTA5.fasl
; compilation finished in 0:00:00.246
; compiling file "/build/stumpwm/src/stumpwm/minor-modes.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/minor-modes-tmpN3CFVWZF.fasl
; compilation finished in 0:00:01.238
REDEFINITION-WITH-DEFUN: redefining STUMPWM::MAKE-SPECIAL-VARIABLE-NAME in DEFUN
REDEFINITION-WITH-DEFUN: redefining STUMPWM::PARSE-MINOR-MODE-OPTIONS in DEFUN
REDEFINITION-WITH-DEFUN: redefining STUMPWM::DEFINE-COMMAND-MACRO in DEFUN
REDEFINITION-WITH-DEFUN: redefining STUMPWM::DEFINE-ENABLE-METHODS in DEFUN
REDEFINITION-WITH-DEFUN: redefining STUMPWM::GENLIGHTER in DEFUN
REDEFINITION-WITH-DEFUN: redefining STUMPWM::DEFINE-HOOKS in DEFUN
REDEFINITION-WITH-DEFUN: redefining STUMPWM:ADD-MINOR-MODE-SCOPE in DEFUN
REDEFINITION-WITH-DEFUN: redefining STUMPWM::GET-SCOPE in DEFUN
REDEFINITION-WITH-DEFUN: redefining STUMPWM::SCOPE-TYPE in DEFUN
REDEFINITION-WITH-DEFUN: redefining STUMPWM::SCOPE-FILTER-TYPE in DEFUN
REDEFINITION-WITH-DEFUN: redefining STUMPWM::SCOPE-CURRENT-OBJECT-FUNCTION in DEFUN
REDEFINITION-WITH-DEFUN: redefining STUMPWM::SCOPE-ALL-OBJECTS-FUNCTION in DEFUN
REDEFINITION-WITH-DEFUN: redefining STUMPWM::FIND-ACTIVE-GLOBAL-MINOR-MODES-FOR-SCOPE in DEFUN
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:DEFINE-MINOR-MODE-SCOPE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:DEFINE-DESCENDED-MINOR-MODE-SCOPE in DEFMACRO
REDEFINITION-WITH-DEFMACRO: redefining STUMPWM:DEFINE-MINOR-MODE in DEFMACRO
; compiling file "/build/stumpwm/src/stumpwm/replace-class.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/replace-class-tmpNK27C0R1.fasl
; compilation finished in 0:00:00.064
REDEFINITION-WITH-DEFGENERIC: redefining DYNAMIC-MIXINS-SWM:REPLACE-CLASS in DEFGENERIC
WARNING: redefining DYNAMIC-MIXINS-SWM:REPLACE-CLASS in DEFGENERIC
; compiling file "/build/stumpwm/src/stumpwm/version.lisp" (written 29 AUG 2026 03:46:42 AM):

; wrote /build/.cache/common-lisp/sbcl-2.6.8-linux-arm64/build/stumpwm/src/stumpwm/version-tmp3BPE71HR.fasl
; compilation finished in 0:00:00.045
; 
; compilation unit finished
;   caught 9 STYLE-WARNING conditions
;   printed 917 notes
[undoing binding stack and other enclosing state... done]
[performing final GC... done]
[saving current Lisp image into stumpwm:
writing 5680 bytes from the static space at 0x2f0100000
writing 40566784 bytes from the dynamic space at 0x1000000000
writing 10962544 bytes from the read-only space at 0xfff580000
writing 0 bytes from the text space at (nil)
done]
/usr/bin/sbcl --non-interactive --eval "(require 'asdf)" --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.6.8, 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-SWM:REPLACE-CLASS in DEFGENERIC
warning: Function dynamic-group-head-layout not found.
warning: Function dynamic-group-head-split-ratio not found.
warning: Symbol exchange-window-with-master not found in package STUMPWM
test "makeinfo" = "no" || makeinfo stumpwm.texi
stumpwm.texi:99: warning: node prev pointer for `Interacting With Unix' is `Screens' but prev is `Internals' in menu
stumpwm.texi:1653: warning: node prev pointer for `Common Built-in Commands' is `Writing Commands' but prev is `StumpWM Types' in menu
This is pdfTeX, Version 3.141592653-2.6-1.40.29 (TeX Live 2026/Arch Linux) (preloaded format=pdfetex)
 restricted \write18 enabled.
entering extended mode
(./stumpwm.texi (/usr/share/texmf-dist/tex/texinfo/texinfo.tex
Loading texinfo [version 2025-12-23.13]: pdf, fonts, glyphs, page headings,
tables, conditionals, indexing, sectioning, toc, environments, defuns, macros,
cross references, insertions, (/usr/share/texmf-dist/tex/generic/epsf/epsf.tex
This is `epsf.tex' v2.7.4 <14 February 2011>
) localization, formatting, microtype, and turning on texinfo input format.)
[1{/var/lib/texmf/fonts/map/pdftex/updmap/pdftex.map}] [2] Chapter 1
Writing index file stumpwm.fn
Cross reference values unknown; you must run TeX again. [1] [2]
Writing index file stumpwm.vr
[3] [4] [5] [6] [7] [8] [9] Chapter 2 [10] [11] [12]
Overfull \hbox (55.34668pt too wide) in paragraph at lines 1177--1177
 []@texttt (stumpwm:define-key stumpwm:*root-map* (stumpwm:kbd "C-z") "echo Zzz
zz...")[] |
[13]
Overfull \hbox (84.09012pt too wide) in paragraph at lines 1218--1218
 []@texttt (stumpwm:define-key stumpwm:*root-map* (stumpwm:kbd "C-f") ^^M*my-fr
ame-bindings*)[] |
[14] [15] [16] [17] [18] Chapter 3 [19] [20] [21] [22] [23] [24] [25]
Overfull \hbox (60.93126pt too wide) in paragraph at lines 1987--1987
 []         @texttt (loop  ; gather all the directions in which there^^Ms a nei
ghbouring frame[] |
[26]
Overfull \hbox (20.85455pt too wide) in paragraph at lines 2037--2037
 []                                           @texttt ;; find all symbols in th
e[] |

Overfull \hbox (112.83356pt too wide) in paragraph at lines 2040--2040
 []                                             @texttt (do-symbols (s (find-pa
ckage "STUMPWM"))[] |

Overfull \hbox (153.07437pt too wide) in paragraph at lines 2041--2041
 []                                               @texttt (push (string-downcas
e (symbol-name s)) acc))[] |
[27] [28] Chapter 4 [29] [30] [31] [32] [33] [34] [35] Chapter 5 [36] [37]
[38] [39] [40] [41] [42] [43] [44]
Overfull \hbox (89.8388pt too wide) in paragraph at lines 3127--3127
 []@texttt (frame-number raise lock &key from-group create restore dump-name cl
ass class-not[] |
[45] [46] [47] Chapter 6 [48] [49] [50] [51] [52] [53] Chapter 7 [54] [55]
[56] [57]
Overfull \hbox (43.6852pt too wide) in paragraph at lines 3940--3940
 []@texttt (register-ml-on-click-id :ml-on-click-focus-window #^^Mml-on-click-f
ocus-window)[] |

Overfull \hbox (20.69044pt too wide) in paragraph at lines 3977--3977
 []@texttt "^(:on-click :ml-on-click-focus-window 308242)window text^(:on-click
-end)"[] |
[58] Chapter 8 [59] [60] [61] [62] [63] [64] Chapter 9 [65] [66] Chapter 10
[67] [68] [69] [70] [71] [72] [73] [74]
Writing index file stumpwm.tp
[75] [76] [77] Chapter 11 [78] [79] [80] Chapter 12 [81] [82] Chapter 13
[83] [84] Chapter 14 [85] [86] [87] [88] [89] [90] [91] [92] Chapter 15
[93] [94] [95] [96] Chapter 16 [97] [98] [99] [100] Chapter 17 [101] [102]
Overfull \hbox (14.94176pt too wide) in paragraph at lines 6210--6210
 []@texttt git clone git@github.com:stumpwm/stumpwm-contrib.git ~/.stumpwm.d/mo
dules[] |

Overfull \hbox (198.89977pt too wide) in paragraph at lines 6263--6263
 []@texttt (quickproject:make-project #p"~/.stumpwm.d/modules/new-module" :depe
nds-on ^^M(stumpwm) :name "new-module")[] |
[103] Chapter 18 [104] [105] [106] [107] Chapter 19 [108] [109]
(Command and Function Index) [110]
No file stumpwm.fns.
(Variable Index) [111] [112]
No file stumpwm.vrs.
[113]
kpathsea: Running mktexpk --mfmode / --bdpi 600 --mag 1+3/600 --dpi 603 ectt1095
mktexpk: Running mf-nowin -progname=mf \mode:=ljfour; mag:=1+3/600; nonstopmode; input ectt1095
This is METAFONT, Version 2.71828182 (TeX Live 2026/Arch Linux) (preloaded base=mf)

(/usr/share/texmf-dist/fonts/source/jknappen/ec/ectt1095.mf
(/usr/share/texmf-dist/fonts/source/jknappen/ec/exbase.mf)
(/usr/share/texmf-dist/fonts/source/jknappen/ec/ectt.mf
(/usr/share/texmf-dist/fonts/source/jknappen/ec/exroman.mf
 Ok (/usr/share/texmf-dist/fonts/source/jknappen/ec/exaccess.mf
 Ok) (/usr/share/texmf-dist/fonts/source/jknappen/ec/expseudo.mf
 Ok) (/usr/share/texmf-dist/fonts/source/jknappen/ec/exruwest.mf
 Ok [192] [193] [194] [195] [196] [197] [198] [199] [200] [201] [202] [203]
[204] [205] [206] [207] [208] [209] [210] [211] [212] [213] [214] [215]
[216] [217] [218] [219] [220] [221] [222] [223])
(/usr/share/texmf-dist/fonts/source/jknappen/ec/exrlwest.mf
 Ok [224] [225] [226] [227] [228] [229] [230] [231] [232] [233] [234] [235]
[236] [237] [238] [239] [240] [241] [242] [243] [244] [245] [246] [247]
[248] [249] [250] [251] [252] [253] [254] [255])
(/usr/share/texmf-dist/fonts/source/jknappen/ec/exrueast.mf
 Ok [128] [129] [130] [131] [132] [133] [134] [135] [136] [137] [138] [139]
[140] [141] [142] [143] [144] [145] [146] [147] [148] [149] [150] [151]
[152] [153] [154] [155] [156] [157])
(/usr/share/texmf-dist/fonts/source/jknappen/ec/exrleast.mf
 Ok [158] [160] [161] [162] [163] [164] [165] [166] [167] [168] [169] [170]
[171] [172] [173] [174] [175] [176] [177] [178] [179] [180] [181] [182]
[183] [184] [185] [186] [187] [188])
(/usr/share/texmf-dist/fonts/source/jknappen/ec/exbraces.mf
 Ok [94] [126] [23] [40] [41] [60] [124] [62] [91] [93] [92] [123] [125]
[95] [127] [32]) (/usr/share/texmf-dist/fonts/source/jknappen/ec/expunct.mf
 Ok [14] [15] [19] [20] [13] [18] [33] [39] [42] [43] [44] [46] [47] [58]
[59] [61] [96] [189] [17] [45] [16] [21] [22])
(/usr/share/texmf-dist/fonts/source/jknappen/ec/exaccent.mf
 Ok [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12])
(/usr/share/texmf-dist/fonts/source/jknappen/ec/exsign.mf
 Ok [24] [34] [35] [36] [37] [64] [191] [159])
(/usr/share/texmf-dist/fonts/source/jknappen/ec/exrlig.mf
 Ok [25] [26] [28] [27] [29] [30] [31])
(/usr/share/texmf-dist/fonts/source/jknappen/ec/exromp.mf
 Ok [38] [63] [190])
(/usr/share/texmf-dist/fonts/source/jknappen/ec/exrulett.mf
 Ok [65] [66] [67] [68] [69] [70] [71] [72] [73] [74] [75] [76] [77] [78]
[79] [80] [81] [82] [83] [84] [85] [86] [87] [88] [89] [90])
(/usr/share/texmf-dist/fonts/source/jknappen/ec/exrllett.mf
 Ok [97] [98] [99] [100] [101] [102] [103] [104] [105] [106] [107] [108]
[109] [110] [111] [112] [113] [114] [115] [116] [117] [118] [119] [120]
[121] [122]) (/usr/share/texmf-dist/fonts/source/jknappen/ec/exrdigit.mf
 Ok [48] [49] [50] [51] [52] [53] [54] [55] [56] [57])
(/usr/share/texmf-dist/fonts/source/jknappen/ec/exmligtb.mf
 Ok) ) ) )
Font metrics written on ectt1095.tfm.
Output written on ectt1095.603gf (256 characters, 47808 bytes).
Transcript written on ectt1095.log.
mktexpk: /build/.texlive/texmf-var/fonts/pk/ljfour/jknappen/ec/ectt1095.603pk: successfully generated.
 )
(see the transcript file for additional information) </build/.texlive/texmf-var
/fonts/pk/ljfour/jknappen/ec/ectt1095.603pk></usr/share/texmf-dist/fonts/type1/
public/amsfonts/cm/cmbx12.pfb></usr/share/texmf-dist/fonts/type1/public/amsfont
s/cm/cmr10.pfb></usr/share/texmf-dist/fonts/type1/public/amsfonts/cm/cmr9.pfb><
/usr/share/texmf-dist/fonts/type1/public/amsfonts/cm/cmsl10.pfb></usr/share/tex
mf-dist/fonts/type1/public/amsfonts/cm/cmsltt10.pfb></usr/share/texmf-dist/font
s/type1/public/amsfonts/cm/cmss10.pfb></usr/share/texmf-dist/fonts/type1/public
/amsfonts/cm/cmsy10.pfb></usr/share/texmf-dist/fonts/type1/public/amsfonts/cm/c
mti10.pfb></usr/share/texmf-dist/fonts/type1/public/amsfonts/cm/cmtt10.pfb>
Output written on stumpwm.pdf (115 pages, 318973 bytes).
Transcript written on stumpwm.log.
This is pdfTeX, Version 3.141592653-2.6-1.40.29 (TeX Live 2026/Arch Linux) (preloaded format=pdfetex)
 restricted \write18 enabled.
entering extended mode
(./stumpwm.texi (/usr/share/texmf-dist/tex/texinfo/texinfo.tex
Loading texinfo [version 2025-12-23.13]: pdf, fonts, glyphs, page headings,
tables, conditionals, indexing, sectioning, toc, environments, defuns, macros,
cross references, insertions, (/usr/share/texmf-dist/tex/generic/epsf/epsf.tex
This is `epsf.tex' v2.7.4 <14 February 2011>
) localization, formatting, microtype, and turning on texinfo input format.)
[1{/var/lib/texmf/fonts/map/pdftex/updmap/pdftex.map}] [2] Chapter 1
(/build/stumpwm/src/stumpwm/stumpwm.aux)
Writing index file stumpwm.fn
[1] [2]
Writing index file stumpwm.vr
[3] [4] [5] [6] [7] [8] [9] Chapter 2 [10] [11] [12]
Overfull \hbox (55.34668pt too wide) in paragraph at lines 1177--1177
 []@texttt (stumpwm:define-key stumpwm:*root-map* (stumpwm:kbd "C-z") "echo Zzz
zz...")[] |
[13]
Overfull \hbox (84.09012pt too wide) in paragraph at lines 1218--1218
 []@texttt (stumpwm:define-key stumpwm:*root-map* (stumpwm:kbd "C-f") ^^M*my-fr
ame-bindings*)[] |
[14] [15] [16] [17] [18] Chapter 3 [19] [20] [21] [22] [23] [24] [25]
Overfull \hbox (60.93126pt too wide) in paragraph at lines 1987--1987
 []         @texttt (loop  ; gather all the directions in which there^^Ms a nei
ghbouring frame[] |
[26]
Overfull \hbox (20.85455pt too wide) in paragraph at lines 2037--2037
 []                                           @texttt ;; find all symbols in th
e[] |

Overfull \hbox (112.83356pt too wide) in paragraph at lines 2040--2040
 []                                             @texttt (do-symbols (s (find-pa
ckage "STUMPWM"))[] |

Overfull \hbox (153.07437pt too wide) in paragraph at lines 2041--2041
 []                                               @texttt (push (string-downcas
e (symbol-name s)) acc))[] |
[27] [28] Chapter 4 [29] [30] [31] [32] [33] [34] [35] Chapter 5 [36] [37]
[38] [39] [40] [41] [42] [43] [44]
Overfull \hbox (89.8388pt too wide) in paragraph at lines 3127--3127
 []@texttt (frame-number raise lock &key from-group create restore dump-name cl
ass class-not[] |
[45] [46] [47] Chapter 6 [48] [49] [50] [51] [52] [53] Chapter 7 [54] [55]
[56] [57]
Overfull \hbox (43.6852pt too wide) in paragraph at lines 3940--3940
 []@texttt (register-ml-on-click-id :ml-on-click-focus-window #^^Mml-on-click-f
ocus-window)[] |

Overfull \hbox (20.69044pt too wide) in paragraph at lines 3977--3977
 []@texttt "^(:on-click :ml-on-click-focus-window 308242)window text^(:on-click
-end)"[] |
[58] Chapter 8 [59] [60] [61] [62] [63] [64] Chapter 9 [65] [66] Chapter 10
[67] [68] [69] [70] [71] [72] [73] [74]
Writing index file stumpwm.tp
[75] [76] [77] Chapter 11 [78] [79] [80] Chapter 12 [81] [82] Chapter 13
[83] [84] Chapter 14 [85] [86] [87] [88] [89] [90] [91] [92] Chapter 15
[93] [94] [95] [96] Chapter 16 [97] [98] [99] [100] Chapter 17 [101] [102]
Overfull \hbox (14.94176pt too wide) in paragraph at lines 6210--6210
 []@texttt git clone git@github.com:stumpwm/stumpwm-contrib.git ~/.stumpwm.d/mo
dules[] |

Overfull \hbox (198.89977pt too wide) in paragraph at lines 6263--6263
 []@texttt (quickproject:make-project #p"~/.stumpwm.d/modules/new-module" :depe
nds-on ^^M(stumpwm) :name "new-module")[] |
[103] Chapter 18 [104] [105] [106] [107] Chapter 19 [108] [109]
(Command and Function Index) [110] (/build/stumpwm/src/stumpwm/stumpwm.fns
[111] [112] [113]) (Variable Index) [114]
(/build/stumpwm/src/stumpwm/stumpwm.vrs [115]) [116] )
(see the transcript file for additional information) </build/.texlive/texmf-var
/fonts/pk/ljfour/jknappen/ec/ectt1095.603pk></usr/share/texmf-dist/fonts/type1/
public/amsfonts/cm/cmbx12.pfb></usr/share/texmf-dist/fonts/type1/public/amsfont
s/cm/cmmi9.pfb></usr/share/texmf-dist/fonts/type1/public/amsfonts/cm/cmr10.pfb>
</usr/share/texmf-dist/fonts/type1/public/amsfonts/cm/cmr9.pfb></usr/share/texm
f-dist/fonts/type1/public/amsfonts/cm/cmsl10.pfb></usr/share/texmf-dist/fonts/t
ype1/public/amsfonts/cm/cmsltt10.pfb></usr/share/texmf-dist/fonts/type1/public/
amsfonts/cm/cmss10.pfb></usr/share/texmf-dist/fonts/type1/public/amsfonts/cm/cm
sy10.pfb></usr/share/texmf-dist/fonts/type1/public/amsfonts/cm/cmti10.pfb></usr
/share/texmf-dist/fonts/type1/public/amsfonts/cm/cmtt10.pfb></usr/share/texmf-d
ist/fonts/type1/public/amsfonts/cm/cmtt9.pfb>
Output written on stumpwm.pdf (118 pages, 362180 bytes).
Transcript written on stumpwm.log.
This is pdfTeX, Version 3.141592653-2.6-1.40.29 (TeX Live 2026/Arch Linux) (preloaded format=pdfetex)
 restricted \write18 enabled.
entering extended mode
(./stumpwm.texi (/usr/share/texmf-dist/tex/texinfo/texinfo.tex
Loading texinfo [version 2025-12-23.13]: pdf, fonts, glyphs, page headings,
tables, conditionals, indexing, sectioning, toc, environments, defuns, macros,
cross references, insertions, (/usr/share/texmf-dist/tex/generic/epsf/epsf.tex
This is `epsf.tex' v2.7.4 <14 February 2011>
) localization, formatting, microtype, and turning on texinfo input format.)
[1{/var/lib/texmf/fonts/map/pdftex/updmap/pdftex.map}] [2] Chapter 1
(/build/stumpwm/src/stumpwm/stumpwm.aux)
Writing index file stumpwm.fn
[1] [2]
Writing index file stumpwm.vr
[3] [4] [5] [6] [7] [8] [9] Chapter 2 [10] [11] [12]
Overfull \hbox (55.34668pt too wide) in paragraph at lines 1177--1177
 []@texttt (stumpwm:define-key stumpwm:*root-map* (stumpwm:kbd "C-z") "echo Zzz
zz...")[] |
[13]
Overfull \hbox (84.09012pt too wide) in paragraph at lines 1218--1218
 []@texttt (stumpwm:define-key stumpwm:*root-map* (stumpwm:kbd "C-f") ^^M*my-fr
ame-bindings*)[] |
[14] [15] [16] [17] [18] Chapter 3 [19] [20] [21] [22] [23] [24] [25]
Overfull \hbox (60.93126pt too wide) in paragraph at lines 1987--1987
 []         @texttt (loop  ; gather all the directions in which there^^Ms a nei
ghbouring frame[] |
[26]
Overfull \hbox (20.85455pt too wide) in paragraph at lines 2037--2037
 []                                           @texttt ;; find all symbols in th
e[] |

Overfull \hbox (112.83356pt too wide) in paragraph at lines 2040--2040
 []                                             @texttt (do-symbols (s (find-pa
ckage "STUMPWM"))[] |

Overfull \hbox (153.07437pt too wide) in paragraph at lines 2041--2041
 []                                               @texttt (push (string-downcas
e (symbol-name s)) acc))[] |
[27] [28] Chapter 4 [29] [30] [31] [32] [33] [34] [35] Chapter 5 [36] [37]
[38] [39] [40] [41] [42] [43] [44]
Overfull \hbox (89.8388pt too wide) in paragraph at lines 3127--3127
 []@texttt (frame-number raise lock &key from-group create restore dump-name cl
ass class-not[] |
[45] [46] [47] Chapter 6 [48] [49] [50] [51] [52] [53] Chapter 7 [54] [55]
[56] [57]
Overfull \hbox (43.6852pt too wide) in paragraph at lines 3940--3940
 []@texttt (register-ml-on-click-id :ml-on-click-focus-window #^^Mml-on-click-f
ocus-window)[] |

Overfull \hbox (20.69044pt too wide) in paragraph at lines 3977--3977
 []@texttt "^(:on-click :ml-on-click-focus-window 308242)window text^(:on-click
-end)"[] |
[58] Chapter 8 [59] [60] [61] [62] [63] [64] Chapter 9 [65] [66] Chapter 10
[67] [68] [69] [70] [71] [72] [73] [74]
Writing index file stumpwm.tp
[75] [76] [77] Chapter 11 [78] [79] [80] Chapter 12 [81] [82] Chapter 13
[83] [84] Chapter 14 [85] [86] [87] [88] [89] [90] [91] [92] Chapter 15
[93] [94] [95] [96] Chapter 16 [97] [98] [99] [100] Chapter 17 [101] [102]
Overfull \hbox (14.94176pt too wide) in paragraph at lines 6210--6210
 []@texttt git clone git@github.com:stumpwm/stumpwm-contrib.git ~/.stumpwm.d/mo
dules[] |

Overfull \hbox (198.89977pt too wide) in paragraph at lines 6263--6263
 []@texttt (quickproject:make-project #p"~/.stumpwm.d/modules/new-module" :depe
nds-on ^^M(stumpwm) :name "new-module")[] |
[103] Chapter 18 [104] [105] [106] [107] Chapter 19 [108] [109]
(Command and Function Index) [110] (/build/stumpwm/src/stumpwm/stumpwm.fns
[111] [112] [113]) (Variable Index) [114]
(/build/stumpwm/src/stumpwm/stumpwm.vrs [115]) [116] )
(see the transcript file for additional information) </build/.texlive/texmf-var
/fonts/pk/ljfour/jknappen/ec/ectt1095.603pk></usr/share/texmf-dist/fonts/type1/
public/amsfonts/cm/cmbx12.pfb></usr/share/texmf-dist/fonts/type1/public/amsfont
s/cm/cmmi9.pfb></usr/share/texmf-dist/fonts/type1/public/amsfonts/cm/cmr10.pfb>
</usr/share/texmf-dist/fonts/type1/public/amsfonts/cm/cmr9.pfb></usr/share/texm
f-dist/fonts/type1/public/amsfonts/cm/cmsl10.pfb></usr/share/texmf-dist/fonts/t
ype1/public/amsfonts/cm/cmsltt10.pfb></usr/share/texmf-dist/fonts/type1/public/
amsfonts/cm/cmss10.pfb></usr/share/texmf-dist/fonts/type1/public/amsfonts/cm/cm
sy10.pfb></usr/share/texmf-dist/fonts/type1/public/amsfonts/cm/cmti10.pfb></usr
/share/texmf-dist/fonts/type1/public/amsfonts/cm/cmtt10.pfb></usr/share/texmf-d
ist/fonts/type1/public/amsfonts/cm/cmtt9.pfb>
Output written on stumpwm.pdf (118 pages, 362180 bytes).
Transcript written on stumpwm.log.
stumpwm.texi:81: warning: no HTML cross-references entry found for `dir'
==> Entering fakeroot environment...
==> Starting package()...
test -z "/build/stumpwm/pkg/stumpwm/usr/bin" || mkdir -p "/build/stumpwm/pkg/stumpwm/usr/bin"
install -m 755 stumpwm "/build/stumpwm/pkg/stumpwm/usr/bin"
test -z "/build/stumpwm/pkg/stumpwm/usr/share/info" || mkdir -p "/build/stumpwm/pkg/stumpwm/usr/share/info"
test "makeinfo" = "no" || install -m 644 stumpwm.info "/build/stumpwm/pkg/stumpwm/usr/share/info"
test "makeinfo" = "no" || install-info --info-dir="/build/stumpwm/pkg/stumpwm/usr/share/info" "/build/stumpwm/pkg/stumpwm/usr/share/info/stumpwm.info"
install: creating directory '/build/stumpwm/pkg/stumpwm/usr/share/doc'
install: creating directory '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm'
'sample-stumpwmrc.lisp' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/sample-stumpwmrc.lisp'
'README.md' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/README.md'
'stumpwm.pdf' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/stumpwm.pdf'
'stumpwm_html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html'
'stumpwm_html/index.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/index.html'
'stumpwm_html/Introduction.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Introduction.html'
'stumpwm_html/Starting-StumpWM.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Starting-StumpWM.html'
'stumpwm_html/Basic-Usage.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Basic-Usage.html'
'stumpwm_html/Basic-Concepts.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Basic-Concepts.html'
'stumpwm_html/Screens-and-Heads.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Screens-and-Heads.html'
'stumpwm_html/Group-Basics.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Group-Basics.html'
'stumpwm_html/Floating-Group-Basics.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Floating-Group-Basics.html'
'stumpwm_html/Dynamic-Group-Basics.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Dynamic-Group-Basics.html'
'stumpwm_html/Dynamic-Group-Index.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Dynamic-Group-Index.html'
'stumpwm_html/Frame-Basics.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Frame-Basics.html'
'stumpwm_html/Window-Basics.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Window-Basics.html'
'stumpwm_html/System-Trays-and-the-Mode-Line.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/System-Trays-and-the-Mode-Line.html'
'stumpwm_html/Manipulating-Frames-and-Windows.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Manipulating-Frames-and-Windows.html'
'stumpwm_html/Moving-Between-Frames.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Moving-Between-Frames.html'
'stumpwm_html/Manipulating-Windows.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Manipulating-Windows.html'
'stumpwm_html/Interacting-with-the-Lisp-process.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Interacting-with-the-Lisp-process.html'
'stumpwm_html/Init-File.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Init-File.html'
'stumpwm_html/Contact-the-StumpWM-developers.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Contact-the-StumpWM-developers.html'
'stumpwm_html/Key-Bindings.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Key-Bindings.html'
'stumpwm_html/List-of-Default-Keybindings.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/List-of-Default-Keybindings.html'
'stumpwm_html/Binding-Keys.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Binding-Keys.html'
'stumpwm_html/Modifiers.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Modifiers.html'
'stumpwm_html/AltGr-Keys.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/AltGr-Keys.html'
'stumpwm_html/Remapped-Keys.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Remapped-Keys.html'
'stumpwm_html/Commands.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Commands.html'
'stumpwm_html/Writing-Commands.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Writing-Commands.html'
'stumpwm_html/StumpWM-Types.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/StumpWM-Types.html'
'stumpwm_html/Common-Built_002din-Commands.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Common-Built_002din-Commands.html'
'stumpwm_html/Message-and-Input-Bar.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Message-and-Input-Bar.html'
'stumpwm_html/Customizing-The-Bar.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Customizing-The-Bar.html'
'stumpwm_html/Using-The-Input-Bar.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Using-The-Input-Bar.html'
'stumpwm_html/Programming-The-Message-Bar.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Programming-The-Message-Bar.html'
'stumpwm_html/Programming-the-Input-Bar.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Programming-the-Input-Bar.html'
'stumpwm_html/Windows.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Windows.html'
'stumpwm_html/Window-Marks.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Window-Marks.html'
'stumpwm_html/Customizing-Window-Appearance.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Customizing-Window-Appearance.html'
'stumpwm_html/Controlling-Raise-And-Map-Requests.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Controlling-Raise-And-Map-Requests.html'
'stumpwm_html/Programming-With-Windows.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Programming-With-Windows.html'
'stumpwm_html/Rule-Based-Window-Placement.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Rule-Based-Window-Placement.html'
'stumpwm_html/Window-Selection-Expressions.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Window-Selection-Expressions.html'
'stumpwm_html/Frames.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Frames.html'
'stumpwm_html/Interactively-Resizing-Frames.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Interactively-Resizing-Frames.html'
'stumpwm_html/Frame-Dumping.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Frame-Dumping.html'
'stumpwm_html/Mode_002dline.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Mode_002dline.html'
'stumpwm_html/Mode_002dline-Interaction.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Mode_002dline-Interaction.html'
'stumpwm_html/Groups.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Groups.html'
'stumpwm_html/Customizing-Groups.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Customizing-Groups.html'
'stumpwm_html/Screens.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Screens.html'
'stumpwm_html/External-Monitors.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/External-Monitors.html'
'stumpwm_html/Programming-With-Screens.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Programming-With-Screens.html'
'stumpwm_html/Minor-Modes.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Minor-Modes.html'
'stumpwm_html/Programming-With-Minor-Modes.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Programming-With-Minor-Modes.html'
'stumpwm_html/Minor-Mode-Scopes.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Minor-Mode-Scopes.html'
'stumpwm_html/Minor-Mode-Example.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Minor-Mode-Example.html'
'stumpwm_html/Internals.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Internals.html'
'stumpwm_html/IO-Loop.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/IO-Loop.html'
'stumpwm_html/Internal-Functions-Documentation.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Internal-Functions-Documentation.html'
'stumpwm_html/Interacting-With-Unix.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Interacting-With-Unix.html'
'stumpwm_html/Interacting-With-X11.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Interacting-With-X11.html'
'stumpwm_html/Miscellaneous-Commands.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Miscellaneous-Commands.html'
'stumpwm_html/Menus.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Menus.html'
'stumpwm_html/StumpWM_0027s-Data-Directory.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/StumpWM_0027s-Data-Directory.html'
'stumpwm_html/Debugging-StumpWM.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Debugging-StumpWM.html'
'stumpwm_html/Sending-a-Bug-Report.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Sending-a-Bug-Report.html'
'stumpwm_html/Timers.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Timers.html'
'stumpwm_html/Getting-Help.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Getting-Help.html'
'stumpwm_html/Colors.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Colors.html'
'stumpwm_html/Behind-The-Scenes-Look-At-Colors.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Behind-The-Scenes-Look-At-Colors.html'
'stumpwm_html/Hooks.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Hooks.html'
'stumpwm_html/Modules.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Modules.html'
'stumpwm_html/Writing-Modules.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Writing-Modules.html'
'stumpwm_html/Hacking.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Hacking.html'
'stumpwm_html/General-Advice.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/General-Advice.html'
'stumpwm_html/Adding-Documentation-and-Editing-This-Manual.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Adding-Documentation-and-Editing-This-Manual.html'
'stumpwm_html/Using-git-with-StumpWM.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Using-git-with-StumpWM.html'
'stumpwm_html/Sending-Patches.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Sending-Patches.html'
'stumpwm_html/Advanced-Configuration.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Advanced-Configuration.html'
'stumpwm_html/Command-and-Function-Index.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Command-and-Function-Index.html'
'stumpwm_html/Variable-Index.html' -> '/build/stumpwm/pkg/stumpwm/usr/share/doc/stumpwm/html/Variable-Index.html'
install: creating directory '/build/stumpwm/pkg/stumpwm/usr/share/xsessions'
'../stumpwm.desktop' -> '/build/stumpwm/pkg/stumpwm/usr/share/xsessions/stumpwm.desktop'
==> Tidying install...
  -> Removing libtool files...
  -> Removing static library files...
  -> Purging unwanted files...
  -> Compressing man and info pages...
==> Checking for packaging issues...
==> WARNING: Package contains reference to $srcdir
usr/bin/stumpwm
==> Creating package "stumpwm"...
  -> Generating .PKGINFO file...
  -> Generating .BUILDINFO file...
  -> Generating .MTREE file...
  -> Compressing package...
==> Leaving fakeroot environment.
==> Finished making: stumpwm 24.11-16 (Sat Aug 29 03:48:19 2026)
==> Cleaning up...
[?12l[?25h