starting phase `set-SOURCE-DATE-EPOCH'
phase `set-SOURCE-DATE-EPOCH' succeeded after 0.0 seconds
starting phase `set-paths'
environment variable `PATH' set to `/gnu/store/i8wj59i9x3p8k253jmhxn5hi2iw0x4hw-sbcl-2.1.4/bin:/gnu/store/v6f44zccwh9z5zk3pjlywjybbi8n2hjh-tar-1.32/bin:/gnu/store/ncydgq2znms5n1d2k5yqshhf58nsixwv-gzip-1.10/bin:/gnu/store/i8h2pcxqdq07ijm3ibkka8f4smn1w48v-bzip2-1.0.8/bin:/gnu/store/9860f1abqj8wjjnwl8a9v54pdcc3bhgf-xz-5.2.4/bin:/gnu/store/60g7r3l01fd7c58yjbm6krgcwj1jkpwg-file-5.38/bin:/gnu/store/n4n560pfvvw50a9369axw5vj5rrqfj1n-diffutils-3.7/bin:/gnu/store/cd5qf3kcnlq35p9k392pjdpdzpsnds70-patch-2.7.6/bin:/gnu/store/hic7snhayfl7m6cpfqqr73nmm19bpqkg-findutils-4.7.0/bin:/gnu/store/swqdvwri9dbv6zssg6v0by7l05hd6wxp-gawk-5.0.1/bin:/gnu/store/ishk7fswcs4gkwcp8mh788z4mvvl9bxh-sed-4.8/bin:/gnu/store/bhs4rj58v8j1narb2454raan2ps38xd8-grep-3.4/bin:/gnu/store/57xj5gcy1jbl9ai2lnrqnpr0dald9i65-coreutils-8.32/bin:/gnu/store/hm40bxnv8jxmbc1lpb7zfimii4xm9m81-make-4.3/bin:/gnu/store/pwcp239kjf7lnj5i4lkdzcfcxwcfyk72-bash-minimal-5.0.16/bin:/gnu/store/mpa04aq8lblbcviyxywxcsb1zbi0mf39-ld-wrapper-0/bin:/gnu/store/m1z7cdbqsqyp9xnjw5cvlb4a7gkcg3m4-binutils-2.34/bin:/gnu/store/rn75fm7adgx3pw5j8pg3bczfqq1y17lk-gcc-7.5.0/bin:/gnu/store/fa6wj5bxkj5ll1d7292a70knmyl7a0cr-glibc-2.31/bin:/gnu/store/fa6wj5bxkj5ll1d7292a70knmyl7a0cr-glibc-2.31/sbin'
environment variable `XDG_DATA_DIRS' set to `/gnu/store/i8wj59i9x3p8k253jmhxn5hi2iw0x4hw-sbcl-2.1.4/share:/gnu/store/y3qhrl8ycjzc2fq7zy547avmfzfq6pd9-sbcl-trivial-gray-streams-0.0.0-1.ebd59b1/share:/gnu/store/v6f44zccwh9z5zk3pjlywjybbi8n2hjh-tar-1.32/share:/gnu/store/ncydgq2znms5n1d2k5yqshhf58nsixwv-gzip-1.10/share:/gnu/store/i8h2pcxqdq07ijm3ibkka8f4smn1w48v-bzip2-1.0.8/share:/gnu/store/9860f1abqj8wjjnwl8a9v54pdcc3bhgf-xz-5.2.4/share:/gnu/store/60g7r3l01fd7c58yjbm6krgcwj1jkpwg-file-5.38/share:/gnu/store/n4n560pfvvw50a9369axw5vj5rrqfj1n-diffutils-3.7/share:/gnu/store/cd5qf3kcnlq35p9k392pjdpdzpsnds70-patch-2.7.6/share:/gnu/store/hic7snhayfl7m6cpfqqr73nmm19bpqkg-findutils-4.7.0/share:/gnu/store/swqdvwri9dbv6zssg6v0by7l05hd6wxp-gawk-5.0.1/share:/gnu/store/ishk7fswcs4gkwcp8mh788z4mvvl9bxh-sed-4.8/share:/gnu/store/bhs4rj58v8j1narb2454raan2ps38xd8-grep-3.4/share:/gnu/store/57xj5gcy1jbl9ai2lnrqnpr0dald9i65-coreutils-8.32/share:/gnu/store/hm40bxnv8jxmbc1lpb7zfimii4xm9m81-make-4.3/share:/gnu/store/pwcp239kjf7lnj5i4lkdzcfcxwcfyk72-bash-minimal-5.0.16/share:/gnu/store/m1z7cdbqsqyp9xnjw5cvlb4a7gkcg3m4-binutils-2.34/share:/gnu/store/rn75fm7adgx3pw5j8pg3bczfqq1y17lk-gcc-7.5.0/share:/gnu/store/fa6wj5bxkj5ll1d7292a70knmyl7a0cr-glibc-2.31/share:/gnu/store/s3dcqzwqaakv1yx37by9chksdbkgih17-glibc-2.31-static/share:/gnu/store/gfapkk5c6hvl1d94m4sqnhn7f9l5gqyh-linux-libre-headers-5.4.20/share'
environment variable `XDG_CONFIG_DIRS' set to `/gnu/store/y3qhrl8ycjzc2fq7zy547avmfzfq6pd9-sbcl-trivial-gray-streams-0.0.0-1.ebd59b1/etc:/gnu/store/swqdvwri9dbv6zssg6v0by7l05hd6wxp-gawk-5.0.1/etc:/gnu/store/fa6wj5bxkj5ll1d7292a70knmyl7a0cr-glibc-2.31/etc'
environment variable `BASH_LOADABLES_PATH' unset
environment variable `C_INCLUDE_PATH' set to `/gnu/store/i8h2pcxqdq07ijm3ibkka8f4smn1w48v-bzip2-1.0.8/include:/gnu/store/9860f1abqj8wjjnwl8a9v54pdcc3bhgf-xz-5.2.4/include:/gnu/store/60g7r3l01fd7c58yjbm6krgcwj1jkpwg-file-5.38/include:/gnu/store/swqdvwri9dbv6zssg6v0by7l05hd6wxp-gawk-5.0.1/include:/gnu/store/hm40bxnv8jxmbc1lpb7zfimii4xm9m81-make-4.3/include:/gnu/store/m1z7cdbqsqyp9xnjw5cvlb4a7gkcg3m4-binutils-2.34/include:/gnu/store/rn75fm7adgx3pw5j8pg3bczfqq1y17lk-gcc-7.5.0/include:/gnu/store/fa6wj5bxkj5ll1d7292a70knmyl7a0cr-glibc-2.31/include:/gnu/store/gfapkk5c6hvl1d94m4sqnhn7f9l5gqyh-linux-libre-headers-5.4.20/include'
environment variable `CPLUS_INCLUDE_PATH' set to `/gnu/store/i8h2pcxqdq07ijm3ibkka8f4smn1w48v-bzip2-1.0.8/include:/gnu/store/9860f1abqj8wjjnwl8a9v54pdcc3bhgf-xz-5.2.4/include:/gnu/store/60g7r3l01fd7c58yjbm6krgcwj1jkpwg-file-5.38/include:/gnu/store/swqdvwri9dbv6zssg6v0by7l05hd6wxp-gawk-5.0.1/include:/gnu/store/hm40bxnv8jxmbc1lpb7zfimii4xm9m81-make-4.3/include:/gnu/store/m1z7cdbqsqyp9xnjw5cvlb4a7gkcg3m4-binutils-2.34/include:/gnu/store/rn75fm7adgx3pw5j8pg3bczfqq1y17lk-gcc-7.5.0/include/c++:/gnu/store/rn75fm7adgx3pw5j8pg3bczfqq1y17lk-gcc-7.5.0/include:/gnu/store/fa6wj5bxkj5ll1d7292a70knmyl7a0cr-glibc-2.31/include:/gnu/store/gfapkk5c6hvl1d94m4sqnhn7f9l5gqyh-linux-libre-headers-5.4.20/include'
environment variable `LIBRARY_PATH' set to `/gnu/store/i8wj59i9x3p8k253jmhxn5hi2iw0x4hw-sbcl-2.1.4/lib:/gnu/store/y3qhrl8ycjzc2fq7zy547avmfzfq6pd9-sbcl-trivial-gray-streams-0.0.0-1.ebd59b1/lib:/gnu/store/i8h2pcxqdq07ijm3ibkka8f4smn1w48v-bzip2-1.0.8/lib:/gnu/store/9860f1abqj8wjjnwl8a9v54pdcc3bhgf-xz-5.2.4/lib:/gnu/store/60g7r3l01fd7c58yjbm6krgcwj1jkpwg-file-5.38/lib:/gnu/store/swqdvwri9dbv6zssg6v0by7l05hd6wxp-gawk-5.0.1/lib:/gnu/store/m1z7cdbqsqyp9xnjw5cvlb4a7gkcg3m4-binutils-2.34/lib:/gnu/store/fa6wj5bxkj5ll1d7292a70knmyl7a0cr-glibc-2.31/lib:/gnu/store/s3dcqzwqaakv1yx37by9chksdbkgih17-glibc-2.31-static/lib:/gnu/store/hwcky7446s952w0mwchhmm211ll07zrq-glibc-utf8-locales-2.31/lib'
environment variable `GUIX_LOCPATH' set to `/gnu/store/hwcky7446s952w0mwchhmm211ll07zrq-glibc-utf8-locales-2.31/lib/locale'
phase `set-paths' succeeded after 0.0 seconds
starting phase `install-locale'
using 'en_US.utf8' locale for category "LC_ALL"
phase `install-locale' succeeded after 0.0 seconds
starting phase `unpack'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/CHANGELOG' -> `./CHANGELOG'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/README.md' -> `./README.md'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/ascii.lisp' -> `./ascii.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/code-pages.lisp' -> `./code-pages.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/conditions.lisp' -> `./conditions.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/decode.lisp' -> `./decode.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/encode.lisp' -> `./encode.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/external-format.lisp' -> `./external-format.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/flexi-streams.asd' -> `./flexi-streams.asd'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/in-memory.lisp' -> `./in-memory.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/input.lisp' -> `./input.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/io.lisp' -> `./io.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/iso-8859.lisp' -> `./iso-8859.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/koi8-r.lisp' -> `./koi8-r.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/length.lisp' -> `./length.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/lw-char-stream.lisp' -> `./lw-char-stream.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/mapping.lisp' -> `./mapping.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/output.lisp' -> `./output.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/packages.lisp' -> `./packages.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/specials.lisp' -> `./specials.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/stream.lisp' -> `./stream.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/strings.lisp' -> `./strings.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/util.lisp' -> `./util.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/README' -> `./test/README'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/hebrew_latin8_cr.txt' -> `./test/hebrew_latin8_cr.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/hebrew_latin8_crlf.txt' -> `./test/hebrew_latin8_crlf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/hebrew_latin8_lf.txt' -> `./test/hebrew_latin8_lf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/hebrew_utf8_cr.txt' -> `./test/hebrew_utf8_cr.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/hebrew_utf8_crlf.txt' -> `./test/hebrew_utf8_crlf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/hebrew_utf8_lf.txt' -> `./test/hebrew_utf8_lf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/kafka_cp1252_cr.txt' -> `./test/kafka_cp1252_cr.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/kafka_cp1252_crlf.txt' -> `./test/kafka_cp1252_crlf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/kafka_cp1252_lf.txt' -> `./test/kafka_cp1252_lf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/kafka_latin1_cr.txt' -> `./test/kafka_latin1_cr.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/kafka_latin1_crlf.txt' -> `./test/kafka_latin1_crlf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/kafka_latin1_lf.txt' -> `./test/kafka_latin1_lf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/kafka_utf8_cr.txt' -> `./test/kafka_utf8_cr.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/kafka_utf8_crlf.txt' -> `./test/kafka_utf8_crlf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/kafka_utf8_lf.txt' -> `./test/kafka_utf8_lf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/packages.lisp' -> `./test/packages.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/russian_koi8r_cr.txt' -> `./test/russian_koi8r_cr.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/russian_koi8r_crlf.txt' -> `./test/russian_koi8r_crlf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/russian_koi8r_lf.txt' -> `./test/russian_koi8r_lf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/russian_utf8_cr.txt' -> `./test/russian_utf8_cr.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/russian_utf8_crlf.txt' -> `./test/russian_utf8_crlf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/russian_utf8_lf.txt' -> `./test/russian_utf8_lf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/test.lisp' -> `./test/test.lisp'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/tilton_ascii_cr.txt' -> `./test/tilton_ascii_cr.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/tilton_ascii_crlf.txt' -> `./test/tilton_ascii_crlf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/tilton_ascii_lf.txt' -> `./test/tilton_ascii_lf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/tilton_utf8_cr.txt' -> `./test/tilton_utf8_cr.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/tilton_utf8_crlf.txt' -> `./test/tilton_utf8_crlf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/tilton_utf8_lf.txt' -> `./test/tilton_utf8_lf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/unicode_demo_ucs2_cr_be.txt' -> `./test/unicode_demo_ucs2_cr_be.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/unicode_demo_ucs2_cr_le.txt' -> `./test/unicode_demo_ucs2_cr_le.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/unicode_demo_ucs2_crlf_be.txt' -> `./test/unicode_demo_ucs2_crlf_be.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/unicode_demo_ucs2_crlf_le.txt' -> `./test/unicode_demo_ucs2_crlf_le.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/unicode_demo_ucs2_lf_be.txt' -> `./test/unicode_demo_ucs2_lf_be.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/unicode_demo_ucs2_lf_le.txt' -> `./test/unicode_demo_ucs2_lf_le.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/unicode_demo_ucs4_cr_be.txt' -> `./test/unicode_demo_ucs4_cr_be.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/unicode_demo_ucs4_cr_le.txt' -> `./test/unicode_demo_ucs4_cr_le.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/unicode_demo_ucs4_crlf_be.txt' -> `./test/unicode_demo_ucs4_crlf_be.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/unicode_demo_ucs4_crlf_le.txt' -> `./test/unicode_demo_ucs4_crlf_le.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/unicode_demo_ucs4_lf_be.txt' -> `./test/unicode_demo_ucs4_lf_be.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/unicode_demo_ucs4_lf_le.txt' -> `./test/unicode_demo_ucs4_lf_le.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/unicode_demo_utf8_cr.txt' -> `./test/unicode_demo_utf8_cr.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/unicode_demo_utf8_crlf.txt' -> `./test/unicode_demo_utf8_crlf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/test/unicode_demo_utf8_lf.txt' -> `./test/unicode_demo_utf8_lf.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/docs/foo.txt' -> `./docs/foo.txt'
`/gnu/store/x2q2ganbzlq1qi7v8w62bpsq940sy324-flexi-streams-1.0.18-checkout/docs/index.html' -> `./docs/index.html'
phase `unpack' succeeded after 0.6 seconds
starting phase `make-git-checkout-writable'
phase `make-git-checkout-writable' succeeded after 0.0 seconds
starting phase `patch-usr-bin-file'
phase `patch-usr-bin-file' succeeded after 0.0 seconds
starting phase `patch-source-shebangs'
phase `patch-source-shebangs' succeeded after 0.0 seconds
starting phase `copy-source'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/util.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/util.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/strings.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/strings.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/stream.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/stream.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/specials.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/specials.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/packages.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/packages.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/output.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/output.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/mapping.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/mapping.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/lw-char-stream.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/lw-char-stream.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/length.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/length.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/koi8-r.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/koi8-r.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/iso-8859.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/iso-8859.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/io.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/io.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/input.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/input.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/in-memory.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/in-memory.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/flexi-streams.asd' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/flexi-streams.asd'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/external-format.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/external-format.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/encode.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/encode.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/decode.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/decode.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/conditions.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/conditions.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/code-pages.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/code-pages.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/ascii.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/ascii.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/README.md' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/README.md'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/CHANGELOG' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/CHANGELOG'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/unicode_demo_utf8_lf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/unicode_demo_utf8_lf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/unicode_demo_utf8_crlf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/unicode_demo_utf8_crlf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/unicode_demo_utf8_cr.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/unicode_demo_utf8_cr.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/unicode_demo_ucs4_lf_le.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/unicode_demo_ucs4_lf_le.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/unicode_demo_ucs4_lf_be.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/unicode_demo_ucs4_lf_be.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/unicode_demo_ucs4_crlf_le.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/unicode_demo_ucs4_crlf_le.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/unicode_demo_ucs4_crlf_be.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/unicode_demo_ucs4_crlf_be.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/unicode_demo_ucs4_cr_le.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/unicode_demo_ucs4_cr_le.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/unicode_demo_ucs4_cr_be.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/unicode_demo_ucs4_cr_be.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/unicode_demo_ucs2_lf_le.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/unicode_demo_ucs2_lf_le.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/unicode_demo_ucs2_lf_be.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/unicode_demo_ucs2_lf_be.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/unicode_demo_ucs2_crlf_le.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/unicode_demo_ucs2_crlf_le.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/unicode_demo_ucs2_crlf_be.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/unicode_demo_ucs2_crlf_be.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/unicode_demo_ucs2_cr_le.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/unicode_demo_ucs2_cr_le.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/unicode_demo_ucs2_cr_be.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/unicode_demo_ucs2_cr_be.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/tilton_utf8_lf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/tilton_utf8_lf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/tilton_utf8_crlf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/tilton_utf8_crlf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/tilton_utf8_cr.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/tilton_utf8_cr.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/tilton_ascii_lf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/tilton_ascii_lf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/tilton_ascii_crlf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/tilton_ascii_crlf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/tilton_ascii_cr.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/tilton_ascii_cr.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/test.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/test.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/russian_utf8_lf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/russian_utf8_lf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/russian_utf8_crlf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/russian_utf8_crlf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/russian_utf8_cr.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/russian_utf8_cr.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/russian_koi8r_lf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/russian_koi8r_lf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/russian_koi8r_crlf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/russian_koi8r_crlf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/russian_koi8r_cr.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/russian_koi8r_cr.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/packages.lisp' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/packages.lisp'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/kafka_utf8_lf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/kafka_utf8_lf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/kafka_utf8_crlf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/kafka_utf8_crlf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/kafka_utf8_cr.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/kafka_utf8_cr.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/kafka_latin1_lf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/kafka_latin1_lf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/kafka_latin1_crlf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/kafka_latin1_crlf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/kafka_latin1_cr.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/kafka_latin1_cr.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/kafka_cp1252_lf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/kafka_cp1252_lf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/kafka_cp1252_crlf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/kafka_cp1252_crlf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/kafka_cp1252_cr.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/kafka_cp1252_cr.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/hebrew_utf8_lf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/hebrew_utf8_lf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/hebrew_utf8_crlf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/hebrew_utf8_crlf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/hebrew_utf8_cr.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/hebrew_utf8_cr.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/hebrew_latin8_lf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/hebrew_latin8_lf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/hebrew_latin8_crlf.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/hebrew_latin8_crlf.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/hebrew_latin8_cr.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/hebrew_latin8_cr.txt'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/test/README' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/test/README'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/docs/index.html' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/docs/index.html'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/docs/foo.txt' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/source/flexi-streams/docs/foo.txt'
phase `copy-source' succeeded after 0.0 seconds
starting phase `configure'

warning: collision encountered:
  /gnu/store/mpa04aq8lblbcviyxywxcsb1zbi0mf39-ld-wrapper-0/bin/ld
  /gnu/store/m1z7cdbqsqyp9xnjw5cvlb4a7gkcg3m4-binutils-2.34/bin/ld
warning: choosing /gnu/store/mpa04aq8lblbcviyxywxcsb1zbi0mf39-ld-wrapper-0/bin/ld
phase `configure' succeeded after 0.3 seconds
starting phase `patch-generated-file-shebangs'
phase `patch-generated-file-shebangs' succeeded after 0.1 seconds
starting phase `build'
Invoking sbcl: "/gnu/store/i8wj59i9x3p8k253jmhxn5hi2iw0x4hw-sbcl-2.1.4/bin/sbcl" "--non-interactive" "--eval" "(require :asdf)" "--eval" "(asdf:load-asd (truename \"/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/flexi-streams.asd\"))" "--eval" "(asdf:compile-system \"flexi-streams\")" 
This is SBCL 2.1.4, 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: System definition file #P"/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/flexi-streams.asd" contains definition for system "flexi-streams-test". Please only define "flexi-streams" and secondary systems with a name starting with "flexi-streams/" (e.g. "flexi-streams/test") in that file.
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/packages.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-USER)
; processing (UNLESS (FIND-SYMBOL # ...) ...)
; processing (DEFPACKAGE :FLEXI-STREAMS ...)

; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/packages-tmpGHU3ALSV.fasl
; compilation finished in 0:00:00.000
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/mapping.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS)
; processing (DEFTYPE OCTET ...)
; processing (DEFTYPE CHAR* ...)
; processing (DEFTYPE STRING* ...)
; processing (DEFTYPE CHAR-CODE-INTEGER ...)
; processing (DEFTYPE CODE-POINT ...)
; processing (DEFMACRO DEFCONSTANT ...)
; processing (DEFUN INVERT-TABLE ...)
; processing (DEFUN MAKE-DECODING-TABLE ...)

; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/mapping-tmpAAURSO1.fasl
; compilation finished in 0:00:00.008
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/ascii.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS)
; processing (DEFCONSTANT +ASCII-TABLE+ ...)

; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/ascii-tmp5GEXGEG5.fasl
; compilation finished in 0:00:00.000
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/koi8-r.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS)
; processing (DEFCONSTANT +KOI8-R-TABLE+ ...)

; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/koi8-r-tmpAR3FSGEY.fasl
; compilation finished in 0:00:00.000
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/iso-8859.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS)
; processing (DEFCONSTANT +ISO-8859-TABLES+ ...)

; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/iso-8859-tmpJAIDFZTC.fasl
; compilation finished in 0:00:00.008
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/code-pages.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS)
; processing (DEFCONSTANT +CODE-PAGE-TABLES+ ...)

; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/code-pages-tmp8V3J6PE9.fasl
; compilation finished in 0:00:00.008
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/specials.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS)
; processing (DEFVAR *STANDARD-OPTIMIZE-SETTINGS* ...)
; processing (DEFVAR *FIXNUM-OPTIMIZE-SETTINGS* ...)
; processing (DEFCONSTANT +LF+ ...)
; processing (DEFCONSTANT +CR+ ...)
; processing (DEFVAR *CURRENT-UNREADER* ...)
; processing (DEFVAR +NAME-MAP+ ...)
; processing (DEFVAR +SHORTCUT-MAP+ ...)
; processing (DEFVAR *DEFAULT-EOL-STYLE* ...)
; processing (DEFVAR *DEFAULT-LITTLE-ENDIAN* ...)
; processing (DEFVAR *SUBSTITUTION-CHAR* ...)
; processing (DEFCONSTANT +ISO-8859-HASHES+ ...)
; processing (DEFCONSTANT +CODE-PAGE-HASHES+ ...)
; processing (DEFCONSTANT +ASCII-HASH+ ...)
; processing (DEFCONSTANT +KOI8-R-HASH+ ...)
; processing (DEFCONSTANT +BUFFER-SIZE+ ...)
; processing (PUSHNEW :FLEXI-STREAMS ...)
; processing (DEFVAR *HYPERDOC-BASE-URI* ...)
; processing (LET (#) ...)

; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/specials-tmp9V47YWQF.fasl
; compilation finished in 0:00:00.016
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/util.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS)
; processing (DEFMACRO WHEN-LET ...)
; processing (DEFMACRO WITH-UNIQUE-NAMES ...)
; processing (DEFMACRO WITH-REBINDING ...)
; processing (DEFUN NORMALIZE-EXTERNAL-FORMAT-NAME ...)
; processing (DEFUN ASCII-NAME-P ...)
; processing (DEFUN KOI8-R-NAME-P ...)
; processing (DEFUN CODE-PAGE-NAME-P ...)
; processing (DEFUN ISO-8859-NAME-P ...)
; processing (DEFUN KNOWN-CODE-PAGE-ID-P ...)
; processing (DEFUN SANS ...)
; processing (DEFUN MAKE-OCTET-BUFFER ...)
; processing (DEFUN TYPE-EQUAL ...)
; processing (DEFUN MAYBE-REWIND ...)
; processing (DEFMACRO LOGAND* ...)
; processing (DEFMACRO LOGIOR* ...)
; processing (DEFMACRO ASH* ...)

; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/util-tmp9BN22RMA.fasl
; compilation finished in 0:00:00.040
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/conditions.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS)
; processing (DEFINE-CONDITION FLEXI-STREAM-ERROR ...)
; processing (DEFINE-CONDITION FLEXI-STREAM-SIMPLE-ERROR ...)
; processing (DEFINE-CONDITION FLEXI-STREAM-ELEMENT-TYPE-ERROR ...)
; processing (DEFINE-CONDITION FLEXI-STREAM-OUT-OF-SYNC-ERROR ...)
; processing (DEFINE-CONDITION IN-MEMORY-STREAM-ERROR ...)
; processing (DEFINE-CONDITION IN-MEMORY-STREAM-SIMPLE-ERROR ...)
; processing (DEFINE-CONDITION IN-MEMORY-STREAM-CLOSED-ERROR ...)
; processing (DEFINE-CONDITION IN-MEMORY-STREAM-POSITION-SPEC-ERROR ...)
; processing (DEFINE-CONDITION EXTERNAL-FORMAT-CONDITION ...)
; processing (DEFINE-CONDITION EXTERNAL-FORMAT-ERROR ...)
; processing (DEFINE-CONDITION EXTERNAL-FORMAT-ENCODING-ERROR ...)
; processing (DEFUN SIGNAL-ENCODING-ERROR ...)

; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/conditions-tmp1CXFJSK9.fasl
; compilation finished in 0:00:00.008
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/external-format.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS)
; processing (DEFCLASS EXTERNAL-FORMAT ...)
; processing (DEFMETHOD MAKE-LOAD-FORM ...)
; processing (DEFCLASS FLEXI-CR-MIXIN ...)
; processing (DEFCLASS FLEXI-CRLF-MIXIN ...)
; processing (DEFCLASS FLEXI-8-BIT-FORMAT ...)
; processing (DEFCLASS FLEXI-CR-8-BIT-FORMAT ...)
; processing (DEFCLASS FLEXI-CRLF-8-BIT-FORMAT ...)
; processing (DEFCLASS FLEXI-ASCII-FORMAT ...)
; processing (DEFCLASS FLEXI-CR-ASCII-FORMAT ...)
; processing (DEFCLASS FLEXI-CRLF-ASCII-FORMAT ...)
; processing (DEFCLASS FLEXI-LATIN-1-FORMAT ...)
; processing (DEFCLASS FLEXI-CR-LATIN-1-FORMAT ...)
; processing (DEFCLASS FLEXI-CRLF-LATIN-1-FORMAT ...)
; processing (DEFCLASS FLEXI-UTF-32-FORMAT ...)
; processing (DEFCLASS FLEXI-UTF-32-LE-FORMAT ...)
; processing (DEFCLASS FLEXI-CR-UTF-32-LE-FORMAT ...)
; processing (DEFCLASS FLEXI-CRLF-UTF-32-LE-FORMAT ...)
; processing (DEFCLASS FLEXI-UTF-32-BE-FORMAT ...)
; processing (DEFCLASS FLEXI-CR-UTF-32-BE-FORMAT ...)
; processing (DEFCLASS FLEXI-CRLF-UTF-32-BE-FORMAT ...)
; processing (DEFCLASS FLEXI-UTF-16-FORMAT ...)
; processing (DEFCLASS FLEXI-UTF-16-LE-FORMAT ...)
; processing (DEFCLASS FLEXI-CR-UTF-16-LE-FORMAT ...)
; processing (DEFCLASS FLEXI-CRLF-UTF-16-LE-FORMAT ...)
; processing (DEFCLASS FLEXI-UTF-16-BE-FORMAT ...)
; processing (DEFCLASS FLEXI-CR-UTF-16-BE-FORMAT ...)
; processing (DEFCLASS FLEXI-CRLF-UTF-16-BE-FORMAT ...)
; processing (DEFCLASS FLEXI-UTF-8-FORMAT ...)
; processing (DEFCLASS FLEXI-CR-UTF-8-FORMAT ...)
; processing (DEFCLASS FLEXI-CRLF-UTF-8-FORMAT ...)
; processing (DEFMETHOD INITIALIZE-INSTANCE ...)
; processing (DEFUN EXTERNAL-FORMAT-CLASS-NAME ...)
; processing (DEFUN MAKE-EXTERNAL-FORMAT% ...)
; processing (DEFUN MAKE-EXTERNAL-FORMAT ...)
; processing (DEFUN MAYBE-CONVERT-EXTERNAL-FORMAT ...)
; processing (DEFUN EXTERNAL-FORMAT-EQUAL ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/external-format.lisp
; in: DEFUN EXTERNAL-FORMAT-EQUAL
;     (EQL (FLEXI-STREAMS:EXTERNAL-FORMAT-ID FLEXI-STREAMS::EF1)
;          (FLEXI-STREAMS:EXTERNAL-FORMAT-ID FLEXI-STREAMS::EF2))
; 
; note: forced to do IF-EQL (cost 15)
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       etc.

; processing (DEFUN NORMALIZE-EXTERNAL-FORMAT ...)
; processing (DEFMETHOD PRINT-OBJECT ...)

; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/external-format-tmpX4BRKI0R.fasl
; compilation finished in 0:00:00.084
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS)
; processing (DEFGENERIC ENCODING-FACTOR ...)
; processing (DEFMETHOD ENCODING-FACTOR ...)
; processing (DEFMETHOD ENCODING-FACTOR ...)
; processing (DEFMETHOD ENCODING-FACTOR ...)
; processing (DEFMETHOD ENCODING-FACTOR ...)
; processing (DEFMETHOD ENCODING-FACTOR ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in: DEFMETHOD ENCODING-FACTOR (FLEXI-CRLF-MIXIN)
;     (* 1.02d0 (CALL-NEXT-METHOD))
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion of first argument in mixed SINGLE-FLOAT-DOUBLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT)
;                               &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT)
;                                                         &REST T).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT)
;                               &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

; processing (DEFGENERIC CHECK-END ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in: DEFGENERIC CHECK-END
;     (- FLEXI-STREAMS::I FLEXI-STREAMS::END)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first result of inline (signed-byte 64) arithmetic

; processing (DEFGENERIC COMPUTE-NUMBER-OF-CHARS ...)
; processing (DEFMETHOD COMPUTE-NUMBER-OF-CHARS ...)
; processing (DEFMETHOD COMPUTE-NUMBER-OF-CHARS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-8-BIT-FORMAT T T T)
;     (- FLEXI-STREAMS::END FLEXI-STREAMS::START)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first result of inline (signed-byte 64) arithmetic

; processing (DEFMETHOD COMPUTE-NUMBER-OF-CHARS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-MIXIN T T T)
;     (SEARCH #(13 10) SEQUENCE :START2 FLEXI-STREAMS::I :END2 FLEXI-STREAMS::END
;             :TEST #'=)
; 
; note: unable to
;   open-code float conversion of first argument in mixed SINGLE-FLOAT-DOUBLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed DOUBLE-FLOAT-SINGLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of first argument in mixed SINGLE-FLOAT-(COMPLEX DOUBLE-FLOAT) numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX DOUBLE-FLOAT)-SINGLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: forced to do GENERIC-= (cost 10)
;       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 (COMPLEX DOUBLE-FLOAT).
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       etc.

; processing (DEFMETHOD COMPUTE-NUMBER-OF-CHARS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-UTF-8-FORMAT T T T)
;     (AREF SEQUENCE FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; processing (DEFMETHOD COMPUTE-NUMBER-OF-CHARS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-UTF-8-FORMAT T T T)
;     (AREF SEQUENCE FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; processing (DEFMETHOD COMPUTE-NUMBER-OF-CHARS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in:
;      DEFMETHOD COMPUTE-NUMBER-OF-CHARS :BEFORE (FLEXI-UTF-16-FORMAT T T T)
;     (- FLEXI-STREAMS::END FLEXI-STREAMS::START)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first result of inline (signed-byte 64) arithmetic

; processing (DEFMETHOD COMPUTE-NUMBER-OF-CHARS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-UTF-16-LE-FORMAT T T T)
;     (AREF SEQUENCE (1+ FLEXI-STREAMS::I))
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; processing (DEFMETHOD COMPUTE-NUMBER-OF-CHARS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-UTF-16-BE-FORMAT T T T)
;     (AREF SEQUENCE FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; processing (DEFMETHOD COMPUTE-NUMBER-OF-CHARS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in:
;      DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-UTF-16-LE-FORMAT T T T)
;     (AREF SEQUENCE (1+ FLEXI-STREAMS::I))
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (AREF SEQUENCE FLEXI-STREAMS::I)
; 
; 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.

; processing (DEFMETHOD COMPUTE-NUMBER-OF-CHARS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in:
;      DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-UTF-16-BE-FORMAT T T T)
;     (AREF SEQUENCE FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (AREF SEQUENCE (1+ FLEXI-STREAMS::I))
; 
; 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.

; processing (DEFMETHOD COMPUTE-NUMBER-OF-CHARS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in:
;      DEFMETHOD COMPUTE-NUMBER-OF-CHARS :BEFORE (FLEXI-UTF-32-FORMAT T T T)
;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT "~A octet~:P cannot be decoded ~
;   using UTF-32 as ~:*~A is not a multiple-value of four."
;                                           LENGTH)
; 
; note: doing signed word to integer coercion (cost 20)

; processing (DEFMETHOD COMPUTE-NUMBER-OF-CHARS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-UTF-32-FORMAT T T T)
;     (CEILING (- FLEXI-STREAMS::END FLEXI-STREAMS::START) 4)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -9223372036854775804 9223372036854775810)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       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 -9223372036854775804 9223372036854775810)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775804 9223372036854775810), not a FIXNUM.
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER -9223372036854775804 9223372036854775810), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The result is a (VALUES
;                        (INTEGER -2305843009213693951 2305843009213693952)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first argument of GENERIC-+

; processing (DEFMETHOD COMPUTE-NUMBER-OF-CHARS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in:
;      DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-UTF-32-LE-FORMAT T T T)
;     (AREF SEQUENCE FLEXI-STREAMS::J)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (= FLEXI-STREAMS:OCTET (AREF SEQUENCE FLEXI-STREAMS::J))
; 
; note: unable to
;   open-code float conversion of first argument in mixed SINGLE-FLOAT-DOUBLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed DOUBLE-FLOAT-SINGLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of first argument in mixed SINGLE-FLOAT-(COMPLEX DOUBLE-FLOAT) numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX DOUBLE-FLOAT)-SINGLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       etc.

;     (DECF LENGTH)
; --> SETQ THE 
; ==>
;   (SB-IMPL::XSUBTRACT 1 LENGTH)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER * 2305843009213693952), not a FIXNUM.
;       The result is a (VALUES (INTEGER * 2305843009213693951) &OPTIONAL), not a (VALUES
;                                                                                  FIXNUM
;                                                                                  &REST
;                                                                                  T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER * 2305843009213693952), not a FIXNUM.
;       The result is a (VALUES (INTEGER * 2305843009213693951) &OPTIONAL), not a (VALUES
;                                                                                  FIXNUM
;                                                                                  &REST
;                                                                                  T).
;       etc.

; processing (DEFMETHOD COMPUTE-NUMBER-OF-CHARS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in:
;      DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-UTF-32-BE-FORMAT T T T)
;     (AREF SEQUENCE FLEXI-STREAMS::J)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (= FLEXI-STREAMS:OCTET (AREF SEQUENCE FLEXI-STREAMS::J))
; 
; note: unable to
;   open-code float conversion of first argument in mixed SINGLE-FLOAT-DOUBLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed DOUBLE-FLOAT-SINGLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of first argument in mixed SINGLE-FLOAT-(COMPLEX DOUBLE-FLOAT) numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX DOUBLE-FLOAT)-SINGLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       etc.

;     (DECF LENGTH)
; --> SETQ THE 
; ==>
;   (SB-IMPL::XSUBTRACT 1 LENGTH)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER * 2305843009213693952), not a FIXNUM.
;       The result is a (VALUES (INTEGER * 2305843009213693951) &OPTIONAL), not a (VALUES
;                                                                                  FIXNUM
;                                                                                  &REST
;                                                                                  T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER * 2305843009213693952), not a FIXNUM.
;       The result is a (VALUES (INTEGER * 2305843009213693951) &OPTIONAL), not a (VALUES
;                                                                                  FIXNUM
;                                                                                  &REST
;                                                                                  T).
;       etc.

; processing (DEFGENERIC COMPUTE-NUMBER-OF-OCTETS ...)
; processing (DEFMETHOD COMPUTE-NUMBER-OF-OCTETS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS :AROUND (T LIST T T)
;     (COERCE LIST 'FLEXI-STREAMS::STRING*)
; 
; note: unable to
;   optimize
; because:
;   STRING* specifies dimensions other than (*) in safe code.

; processing (DEFMETHOD COMPUTE-NUMBER-OF-OCTETS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-8-BIT-FORMAT T T T)
;     (- FLEXI-STREAMS::END FLEXI-STREAMS::START)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first result of inline (signed-byte 64) arithmetic

; processing (DEFMETHOD COMPUTE-NUMBER-OF-OCTETS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-UTF-8-FORMAT T T T)
;     (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; processing (DEFMETHOD COMPUTE-NUMBER-OF-OCTETS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-CRLF-UTF-8-FORMAT T T T)
;     (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; processing (DEFMETHOD COMPUTE-NUMBER-OF-OCTETS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-UTF-16-FORMAT T T T)
;     (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; processing (DEFMETHOD COMPUTE-NUMBER-OF-OCTETS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in:
;      DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-CRLF-UTF-16-LE-FORMAT T T T)
;     (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; processing (DEFMETHOD COMPUTE-NUMBER-OF-OCTETS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in:
;      DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-CRLF-UTF-16-BE-FORMAT T T T)
;     (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; processing (DEFMETHOD COMPUTE-NUMBER-OF-OCTETS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-UTF-32-FORMAT T T T)
;     (* 4 (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -36893488147419103228 36893488147419103228)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER -9223372036854775807 9223372036854775807), not a (UNSIGNED-BYTE
;                                                                                          64).
;       The result is a (VALUES
;                        (INTEGER -36893488147419103228 36893488147419103228)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.

;     (- FLEXI-STREAMS::END FLEXI-STREAMS::START)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first result of inline (signed-byte 64) arithmetic

; processing (DEFMETHOD COMPUTE-NUMBER-OF-OCTETS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-CRLF-MIXIN T T T)
;     (+ (CALL-NEXT-METHOD)
;        (*
;         (CASE (FLEXI-STREAMS:EXTERNAL-FORMAT-NAME FORMAT)
;           (:UTF-32 4)
;           (OTHERWISE 1))
;         (COUNT #\Newline STRING :START FLEXI-STREAMS::START :END
;                FLEXI-STREAMS::END :TEST #'CHAR=)))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (MOD 18446744073709551601), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The second argument is a (MOD 18446744073709551601), not a (SIGNED-BYTE
;                                                                   64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: doing unsigned word to integer coercion (cost 20), for:
;       the second argument of GENERIC-+

; processing (DEFGENERIC CHARACTER-LENGTH ...)
; processing (DEFMETHOD CHARACTER-LENGTH ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/length.lisp
; in:
;      DEFMETHOD CHARACTER-LENGTH :AROUND (FLEXI-CRLF-MIXIN (EQL #\Newline))
;     (+ (CALL-NEXT-METHOD FORMAT FLEXI-STREAMS::+CR+)
;        (CALL-NEXT-METHOD FORMAT FLEXI-STREAMS::+LF+))
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-(COMPLEX FLOAT) numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion of first argument in mixed SINGLE-FLOAT-DOUBLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed DOUBLE-FLOAT-SINGLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of first argument in mixed SINGLE-FLOAT-(COMPLEX DOUBLE-FLOAT) numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX DOUBLE-FLOAT)-SINGLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
;                                                                &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a 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
;                                                                &REST T).
;       etc.

; processing (DEFMETHOD CHARACTER-LENGTH ...)
; processing (DEFMETHOD CHARACTER-LENGTH ...)

; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/length-tmpQ371UGST.fasl
; compilation finished in 0:00:00.180
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/encode.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS)
; processing (DEFGENERIC CHAR-TO-OCTETS ...)
; processing (DEFGENERIC WRITE-SEQUENCE* ...)
; processing (DEFGENERIC STRING-TO-OCTETS* ...)
; processing (DEFMETHOD STRING-TO-OCTETS* ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/encode.lisp
; in: DEFMETHOD STRING-TO-OCTETS* :AROUND (T LIST T T)
;     (COERCE LIST 'FLEXI-STREAMS::STRING*)
; 
; note: unable to
;   optimize
; because:
;   STRING* specifies dimensions other than (*) in safe code.

; processing (DEFMACRO DEFINE-SEQUENCE-WRITERS ...)
; processing (DEFMACRO DEFINE-CHAR-ENCODERS ...)
; processing (DEFINE-CHAR-ENCODERS (FLEXI-LATIN-1-FORMAT FLEXI-CR-LATIN-1-FORMAT ...) ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/encode.lisp
; in:
;      DEFINE-CHAR-ENCODERS (FLEXI-LATIN-1-FORMAT FLEXI-CR-LATIN-1-FORMAT
;                        FLEXI-CRLF-LATIN-1-FORMAT)
;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not a LATIN-1 character."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-LATIN-1-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-LATIN-1-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-LATIN-1-FORMAT)
;       (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (WHEN (> FLEXI-STREAMS:OCTET 255)
;           (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                                 "~S (code ~A) is not a LATIN-1 character."
;                                                 FLEXI-STREAMS::CHAR-GETTER
;                                                 FLEXI-STREAMS:OCTET))
;         (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET)))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER102 #:BUFFER-POS103)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not a LATIN-1 character."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not a LATIN-1 character."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-LATIN-1-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-LATIN-1-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-LATIN-1-FORMAT)
;       (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (WHEN (> FLEXI-STREAMS:OCTET 255)
;           (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                                 "~S (code ~A) is not a LATIN-1 character."
;                                                 FLEXI-STREAMS::CHAR-GETTER
;                                                 FLEXI-STREAMS:OCTET))
;         (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET)))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY LET WHEN IF 
; --> FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER270 #:BUFFER-POS271)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY LET CHAR-CODE LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY LET WHEN IF FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET 
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY LET CHAR-CODE LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY LET WHEN IF FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET 
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER442 #:BUFFER-POS443)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; processing (DEFINE-CHAR-ENCODERS (FLEXI-ASCII-FORMAT FLEXI-CR-ASCII-FORMAT ...) ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/encode.lisp
; in:
;      DEFINE-CHAR-ENCODERS (FLEXI-ASCII-FORMAT FLEXI-CR-ASCII-FORMAT
;                        FLEXI-CRLF-ASCII-FORMAT)
;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not an ASCII character."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT)
;       (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (WHEN (> FLEXI-STREAMS:OCTET 127)
;           (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                                 "~S (code ~A) is not an ASCII character."
;                                                 FLEXI-STREAMS::CHAR-GETTER
;                                                 FLEXI-STREAMS:OCTET))
;         (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET)))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER102 #:BUFFER-POS103)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not an ASCII character."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not an ASCII character."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT)
;       (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (WHEN (> FLEXI-STREAMS:OCTET 127)
;           (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                                 "~S (code ~A) is not an ASCII character."
;                                                 FLEXI-STREAMS::CHAR-GETTER
;                                                 FLEXI-STREAMS:OCTET))
;         (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET)))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY LET WHEN IF 
; --> FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER270 #:BUFFER-POS271)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY LET CHAR-CODE LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY LET WHEN IF FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET 
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY LET CHAR-CODE LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY LET WHEN IF FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET 
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER442 #:BUFFER-POS443)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; processing (DEFINE-CHAR-ENCODERS (FLEXI-8-BIT-FORMAT FLEXI-CR-8-BIT-FORMAT ...) ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/encode.lisp
; in:
;      DEFINE-CHAR-ENCODERS (FLEXI-8-BIT-FORMAT FLEXI-CR-8-BIT-FORMAT
;                        FLEXI-CRLF-8-BIT-FORMAT)
;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not in this encoding."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT)
;       (WITH-ACCESSORS ((FLEXI-STREAMS::ENCODING-HASH
;                         FLEXI-STREAMS::EXTERNAL-FORMAT-ENCODING-HASH))
;           FORMAT
;         (LET ((FLEXI-STREAMS:OCTET #))
;           (UNLESS FLEXI-STREAMS:OCTET
;             (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                                   "~S (code ~A) is not in this encoding."
;                                                   FLEXI-STREAMS::CHAR-GETTER
;                                                   FLEXI-STREAMS:OCTET))
;           (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER109 #:BUFFER-POS110)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not in this encoding."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not in this encoding."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT)
;       (WITH-ACCESSORS ((FLEXI-STREAMS::ENCODING-HASH
;                         FLEXI-STREAMS::EXTERNAL-FORMAT-ENCODING-HASH))
;           FORMAT
;         (LET ((FLEXI-STREAMS:OCTET #))
;           (UNLESS FLEXI-STREAMS:OCTET
;             (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                                   "~S (code ~A) is not in this encoding."
;                                                   FLEXI-STREAMS::CHAR-GETTER
;                                                   FLEXI-STREAMS:OCTET))
;           (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY WITH-ACCESSORS LET SYMBOL-MACROLET LET 
; ==>
;   (GETHASH
;    (CHAR-CODE
;     (LET ((#:CHAR0 FLEXI-STREAMS::CHAR-GETTER))
;       (DECLARE (CHARACTER #:CHAR0))
;       (IF (CHAR= #:CHAR0 #\Newline)
;           #\Return
;           #:CHAR0)))
;    FLEXI-STREAMS::ENCODING-HASH)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY WITH-ACCESSORS LET SYMBOL-MACROLET LET 
; --> UNLESS IF FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET 
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER285 #:BUFFER-POS286)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY WITH-ACCESSORS LET SYMBOL-MACROLET LET 
; ==>
;   (GETHASH
;    (CHAR-CODE
;     (LET ((#:CHAR0 FLEXI-STREAMS::CHAR-GETTER))
;       (DECLARE (CHARACTER #:CHAR0))
;       (IF (CHAR= #:CHAR0 #\Newline)
;           #\Return
;           #:CHAR0)))
;    FLEXI-STREAMS::ENCODING-HASH)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY WITH-ACCESSORS LET SYMBOL-MACROLET LET UNLESS IF 
; --> FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY WITH-ACCESSORS LET SYMBOL-MACROLET LET 
; ==>
;   (GETHASH
;    (CHAR-CODE
;     (LET ((#:CHAR0 FLEXI-STREAMS::CHAR-GETTER))
;       (DECLARE (CHARACTER #:CHAR0))
;       (IF (CHAR= #:CHAR0 #\Newline)
;           #\Return
;           #:CHAR0)))
;    FLEXI-STREAMS::ENCODING-HASH)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY WITH-ACCESSORS LET SYMBOL-MACROLET LET UNLESS IF 
; --> FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER465 #:BUFFER-POS466)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; processing (DEFINE-CHAR-ENCODERS (FLEXI-UTF-8-FORMAT FLEXI-CR-UTF-8-FORMAT ...) ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/encode.lisp
; in:
;      DEFINE-CHAR-ENCODERS (FLEXI-UTF-8-FORMAT FLEXI-CR-UTF-8-FORMAT
;                        FLEXI-CRLF-UTF-8-FORMAT)
;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT)
;       (LET ((CHAR-CODE (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (TAGBODY
;           (COND (# # #) (# # #) (# # #) (T #))
;           (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGIOR* 128 #))
;          FLEXI-STREAMS::TWO
;           (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGIOR* 128 #))
;          FLEXI-STREAMS::ONE
;           (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGIOR* 128 #))
;          FLEXI-STREAMS::ZERO)))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER148 #:BUFFER-POS149)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT)
;       (LET ((CHAR-CODE (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (TAGBODY
;           (COND (# # #) (# # #) (# # #) (T #))
;           (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGIOR* 128 #))
;          FLEXI-STREAMS::TWO
;           (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGIOR* 128 #))
;          FLEXI-STREAMS::ONE
;           (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGIOR* 128 #))
;          FLEXI-STREAMS::ZERO)))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER356 #:BUFFER-POS357)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY LET CHAR-CODE LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY LET CHAR-CODE LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER578 #:BUFFER-POS579)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; processing (DEFINE-CHAR-ENCODERS (FLEXI-UTF-16-LE-FORMAT FLEXI-CR-UTF-16-LE-FORMAT ...) ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/encode.lisp
; in:
;      DEFINE-CHAR-ENCODERS (FLEXI-UTF-16-LE-FORMAT FLEXI-CR-UTF-16-LE-FORMAT
;                        FLEXI-CRLF-UTF-16-LE-FORMAT)
;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-16-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-16-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-16-LE-FORMAT)
;       (FLET ((FLEXI-STREAMS::WRITE-WORD (FLEXI-STREAMS::WORD)
;                (FLEXI-STREAMS::OCTET-WRITER #)
;                (FLEXI-STREAMS::OCTET-WRITER #)))
;         (DECLARE (INLINE FLEXI-STREAMS::WRITE-WORD))
;         (LET ((CHAR-CODE #))
;           (DECLARE (TYPE FLEXI-STREAMS::CHAR-CODE-INTEGER CHAR-CODE))
;           (COND (# #) (T # # #)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER129 #:BUFFER-POS130)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-16-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-16-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-16-LE-FORMAT)
;       (FLET ((FLEXI-STREAMS::WRITE-WORD (FLEXI-STREAMS::WORD)
;                (FLEXI-STREAMS::OCTET-WRITER #)
;                (FLEXI-STREAMS::OCTET-WRITER #)))
;         (DECLARE (INLINE FLEXI-STREAMS::WRITE-WORD))
;         (LET ((CHAR-CODE #))
;           (DECLARE (TYPE FLEXI-STREAMS::CHAR-CODE-INTEGER CHAR-CODE))
;           (COND (# #) (T # # #)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER318 #:BUFFER-POS319)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET CHAR-CODE LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET CHAR-CODE LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER519 #:BUFFER-POS520)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; processing (DEFINE-CHAR-ENCODERS (FLEXI-UTF-16-BE-FORMAT FLEXI-CR-UTF-16-BE-FORMAT ...) ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/encode.lisp
; in:
;      DEFINE-CHAR-ENCODERS (FLEXI-UTF-16-BE-FORMAT FLEXI-CR-UTF-16-BE-FORMAT
;                        FLEXI-CRLF-UTF-16-BE-FORMAT)
;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-16-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-16-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-16-BE-FORMAT)
;       (FLET ((FLEXI-STREAMS::WRITE-WORD (FLEXI-STREAMS::WORD)
;                (FLEXI-STREAMS::OCTET-WRITER #)
;                (FLEXI-STREAMS::OCTET-WRITER #)))
;         (DECLARE (INLINE FLEXI-STREAMS::WRITE-WORD))
;         (LET ((CHAR-CODE #))
;           (DECLARE (TYPE FLEXI-STREAMS::CHAR-CODE-INTEGER CHAR-CODE))
;           (COND (# #) (T # # #)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER129 #:BUFFER-POS130)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-16-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-16-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-16-BE-FORMAT)
;       (FLET ((FLEXI-STREAMS::WRITE-WORD (FLEXI-STREAMS::WORD)
;                (FLEXI-STREAMS::OCTET-WRITER #)
;                (FLEXI-STREAMS::OCTET-WRITER #)))
;         (DECLARE (INLINE FLEXI-STREAMS::WRITE-WORD))
;         (LET ((CHAR-CODE #))
;           (DECLARE (TYPE FLEXI-STREAMS::CHAR-CODE-INTEGER CHAR-CODE))
;           (COND (# #) (T # # #)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER318 #:BUFFER-POS319)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET CHAR-CODE LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET CHAR-CODE LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER519 #:BUFFER-POS520)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; processing (DEFINE-CHAR-ENCODERS (FLEXI-UTF-32-LE-FORMAT FLEXI-CR-UTF-32-LE-FORMAT ...) ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/encode.lisp
; in:
;      DEFINE-CHAR-ENCODERS (FLEXI-UTF-32-LE-FORMAT FLEXI-CR-UTF-32-LE-FORMAT
;                        FLEXI-CRLF-UTF-32-LE-FORMAT)
;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT)
;       (LET ((CHAR-CODE (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGAND* 255 CHAR-CODE))
;         (FLEXI-STREAMS::OCTET-WRITER
;          (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -8)))
;         (FLEXI-STREAMS::OCTET-WRITER
;          (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -16)))
;         (FLEXI-STREAMS::OCTET-WRITER
;          (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -24)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER121 #:BUFFER-POS122)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT)
;       (LET ((CHAR-CODE (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGAND* 255 CHAR-CODE))
;         (FLEXI-STREAMS::OCTET-WRITER
;          (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -8)))
;         (FLEXI-STREAMS::OCTET-WRITER
;          (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -16)))
;         (FLEXI-STREAMS::OCTET-WRITER
;          (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -24)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER302 #:BUFFER-POS303)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY LET CHAR-CODE LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY LET CHAR-CODE LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER491 #:BUFFER-POS492)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; processing (DEFINE-CHAR-ENCODERS (FLEXI-UTF-32-BE-FORMAT FLEXI-CR-UTF-32-BE-FORMAT ...) ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/encode.lisp
; in:
;      DEFINE-CHAR-ENCODERS (FLEXI-UTF-32-BE-FORMAT FLEXI-CR-UTF-32-BE-FORMAT
;                        FLEXI-CRLF-UTF-32-BE-FORMAT)
;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT)
;       (LET ((CHAR-CODE (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (FLEXI-STREAMS::OCTET-WRITER
;          (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -24)))
;         (FLEXI-STREAMS::OCTET-WRITER
;          (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -16)))
;         (FLEXI-STREAMS::OCTET-WRITER
;          (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -8)))
;         (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGAND* 255 CHAR-CODE))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER121 #:BUFFER-POS122)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT)
;       (LET ((CHAR-CODE (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (FLEXI-STREAMS::OCTET-WRITER
;          (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -24)))
;         (FLEXI-STREAMS::OCTET-WRITER
;          (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -16)))
;         (FLEXI-STREAMS::OCTET-WRITER
;          (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* CHAR-CODE -8)))
;         (FLEXI-STREAMS::OCTET-WRITER (FLEXI-STREAMS::LOGAND* 255 CHAR-CODE))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER302 #:BUFFER-POS303)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY LET CHAR-CODE LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY LET CHAR-CODE LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET LOOP BLOCK LET TAGBODY MACROLET 
; --> SYMBOL-MACROLET PROGN LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS FLEXI-STREAMS::WRITE-OCTET BLOCK SETF LET* 
; ==>
;   (FUNCALL #'(SETF AREF) #:NEW1 #:BUFFER491 #:BUFFER-POS492)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT
;                               SINGLE-FLOAT), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (CHAR SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS MACROLET ETYPECASE LET COND IF IF PROGN 
; --> FLEXI-STREAMS::ITERATE LOOP BLOCK LET TAGBODY PROGN SYMBOL-MACROLET 
; --> LOCALLY FLET LET FLEXI-STREAMS::CHAR-GETTER 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET 
; ==>
;   (POSITION #\Newline SEQUENCE :TEST #'CHAR= :START FLEXI-STREAMS::START :END
;             FLEXI-STREAMS::END :FROM-END T)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT)
;                        &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> MACROLET LABELS SETQ SETF LET* COND IF THE LET COND IF IF 
; ==>
;   (+ FLEXI-STREAMS::COLUMN (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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 &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-WRITERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; ==>
;   (MIN FLEXI-STREAMS::+BUFFER-SIZE+
;        (CEILING
;         (* FLEXI-STREAMS::FACTOR (- FLEXI-STREAMS::END FLEXI-STREAMS::START))))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; processing (DEFMETHOD CHAR-TO-OCTETS ...)
; processing (DEFMETHOD CHAR-TO-OCTETS ...)

; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/encode-tmp2OWI3Q7U.fasl
; compilation finished in 0:00:01.212
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/decode.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS)
; processing (DEFUN RECOVER-FROM-ENCODING-ERROR ...)
; processing (DEFGENERIC OCTETS-TO-CHAR-CODE ...)
; processing (DEFGENERIC OCTETS-TO-STRING* ...)
; processing (DEFMETHOD OCTETS-TO-STRING* ...)
; processing (DEFMACRO DEFINE-SEQUENCE-READERS ...)
; processing (DEFMACRO DEFINE-CHAR-DECODERS ...)
; processing (DEFINE-CHAR-DECODERS (FLEXI-LATIN-1-FORMAT FLEXI-CR-LATIN-1-FORMAT ...) ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/decode.lisp
; in:
;      DEFINE-CHAR-DECODERS (FLEXI-LATIN-1-FORMAT FLEXI-CR-LATIN-1-FORMAT
;                        FLEXI-CRLF-LATIN-1-FORMAT)
;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-LATIN-1-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-LATIN-1-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-LATIN-1-FORMAT)
;       FLEXI-STREAMS::OCTET-GETTER)
; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET 
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK SYMBOL-MACROLET LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET 
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK SYMBOL-MACROLET LET WHEN IF AND IF OR LET 
; --> IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET PROGN FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET PROGN FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET PROGN FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET PROGN LET PROGN FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY FLET #:GET-CHAR-CODE4 BLOCK LET PROGN FLEXI-STREAMS::OCTET-GETTER 
; --> BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET PROGN FLEXI-STREAMS::OCTET-GETTER BLOCK 
; --> PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET PROGN FLEXI-STREAMS::OCTET-GETTER BLOCK 
; --> PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-FLOAT numeric operation
; due to type uncertainty:
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-(COMPLEX FLOAT) numeric operation
; due to type uncertainty:
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; processing (DEFINE-CHAR-DECODERS (FLEXI-ASCII-FORMAT FLEXI-CR-ASCII-FORMAT ...) ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/decode.lisp
; in:
;      DEFINE-CHAR-DECODERS (FLEXI-ASCII-FORMAT FLEXI-CR-ASCII-FORMAT
;                        FLEXI-CRLF-ASCII-FORMAT)
;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT)
;       (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;         (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;             FLEXI-STREAMS:OCTET)))
; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET 
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK SYMBOL-MACROLET LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET 
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK SYMBOL-MACROLET LET WHEN IF AND IF OR LET 
; --> IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;           (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;            "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;           FLEXI-STREAMS:OCTET))
; --> LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT)
;       (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;         (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;             FLEXI-STREAMS:OCTET)))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;           (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;            "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;           FLEXI-STREAMS:OCTET))
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT)
;       (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;         (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;             FLEXI-STREAMS:OCTET)))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;           (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;            "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;           FLEXI-STREAMS:OCTET))
; --> LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT)
;       (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;         (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;             FLEXI-STREAMS:OCTET)))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET PROGN LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET PROGN LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;           (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;            "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;           FLEXI-STREAMS:OCTET))
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT)
;       (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;         (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;             FLEXI-STREAMS:OCTET)))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;           (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;            "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;           FLEXI-STREAMS:OCTET))
; --> LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT)
;       (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;         (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;             FLEXI-STREAMS:OCTET)))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-FLOAT numeric operation
; due to type uncertainty:
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-(COMPLEX FLOAT) numeric operation
; due to type uncertainty:
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;           (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;            "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;           FLEXI-STREAMS:OCTET))
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-ASCII-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-ASCII-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-ASCII-FORMAT)
;       (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;         (IF (> (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;             FLEXI-STREAMS:OCTET)))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; processing (DEFINE-CHAR-DECODERS (FLEXI-8-BIT-FORMAT FLEXI-CR-8-BIT-FORMAT ...) ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/decode.lisp
; in:
;      DEFINE-CHAR-DECODERS (FLEXI-8-BIT-FORMAT FLEXI-CR-8-BIT-FORMAT
;                        FLEXI-CRLF-8-BIT-FORMAT)
;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT)
;       (WITH-ACCESSORS ((FLEXI-STREAMS::DECODING-TABLE
;                         FLEXI-STREAMS::EXTERNAL-FORMAT-DECODING-TABLE))
;           FORMAT
;         (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;           (LET (#)
;             (IF #
;                 #
;                 CHAR-CODE)))))
; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET 
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK SYMBOL-MACROLET LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET 
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK SYMBOL-MACROLET LET WHEN IF AND IF OR LET 
; --> IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (LET ((CHAR-CODE (AREF # #)))
;         (IF (OR (NULL CHAR-CODE) (= # 65533))
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;             CHAR-CODE)))
; --> LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT)
;       (WITH-ACCESSORS ((FLEXI-STREAMS::DECODING-TABLE
;                         FLEXI-STREAMS::EXTERNAL-FORMAT-DECODING-TABLE))
;           FORMAT
;         (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;           (LET (#)
;             (IF #
;                 #
;                 CHAR-CODE)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (LET ((CHAR-CODE (AREF # #)))
;         (IF (OR (NULL CHAR-CODE) (= # 65533))
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;             CHAR-CODE)))
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT)
;       (WITH-ACCESSORS ((FLEXI-STREAMS::DECODING-TABLE
;                         FLEXI-STREAMS::EXTERNAL-FORMAT-DECODING-TABLE))
;           FORMAT
;         (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;           (LET (#)
;             (IF #
;                 #
;                 CHAR-CODE)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (LET ((CHAR-CODE (AREF # #)))
;         (IF (OR (NULL CHAR-CODE) (= # 65533))
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;             CHAR-CODE)))
; --> LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT)
;       (WITH-ACCESSORS ((FLEXI-STREAMS::DECODING-TABLE
;                         FLEXI-STREAMS::EXTERNAL-FORMAT-DECODING-TABLE))
;           FORMAT
;         (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;           (LET (#)
;             (IF #
;                 #
;                 CHAR-CODE)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET PROGN LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET PROGN LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (LET ((CHAR-CODE (AREF # #)))
;         (IF (OR (NULL CHAR-CODE) (= # 65533))
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;             CHAR-CODE)))
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT)
;       (WITH-ACCESSORS ((FLEXI-STREAMS::DECODING-TABLE
;                         FLEXI-STREAMS::EXTERNAL-FORMAT-DECODING-TABLE))
;           FORMAT
;         (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;           (LET (#)
;             (IF #
;                 #
;                 CHAR-CODE)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (LET ((CHAR-CODE (AREF # #)))
;         (IF (OR (NULL CHAR-CODE) (= # 65533))
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;             CHAR-CODE)))
; --> LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT)
;       (WITH-ACCESSORS ((FLEXI-STREAMS::DECODING-TABLE
;                         FLEXI-STREAMS::EXTERNAL-FORMAT-DECODING-TABLE))
;           FORMAT
;         (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;           (LET (#)
;             (IF #
;                 #
;                 CHAR-CODE)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-FLOAT numeric operation
; due to type uncertainty:
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-(COMPLEX FLOAT) numeric operation
; due to type uncertainty:
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (LET ((CHAR-CODE (AREF # #)))
;         (IF (OR (NULL CHAR-CODE) (= # 65533))
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "No character which corresponds to octet #x~X." FLEXI-STREAMS:OCTET)
;             CHAR-CODE)))
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-8-BIT-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-8-BIT-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-8-BIT-FORMAT)
;       (WITH-ACCESSORS ((FLEXI-STREAMS::DECODING-TABLE
;                         FLEXI-STREAMS::EXTERNAL-FORMAT-DECODING-TABLE))
;           FORMAT
;         (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;           (LET (#)
;             (IF #
;                 #
;                 CHAR-CODE)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; processing (DEFINE-CHAR-DECODERS (FLEXI-UTF-8-FORMAT FLEXI-CR-UTF-8-FORMAT ...) ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/decode.lisp
; in:
;      DEFINE-CHAR-DECODERS (FLEXI-UTF-8-FORMAT FLEXI-CR-UTF-8-FORMAT
;                        FLEXI-CRLF-UTF-8-FORMAT)
;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (FLET (#)
;             (LET #
;               #
;               #)))))
; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET 
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK SYMBOL-MACROLET LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET 
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK SYMBOL-MACROLET LET WHEN IF AND IF OR LET 
; --> IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (FLET (#)
;             (LET #
;               #
;               #)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; 
; caught STYLE-WARNING:
;   This is not a (MOD 1114112):
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; 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.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (FLET (#)
;             (LET #
;               #
;               #)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (FLET (#)
;             (LET #
;               #
;               #)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET PROGN LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET PROGN LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; 
; caught STYLE-WARNING:
;   This is not a (MOD 1114112):
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; 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.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (FLET (#)
;             (LET #
;               #
;               #)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (FLET (#)
;             (LET #
;               #
;               #)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET 
; ==>
;   (BLOCK FLEXI-STREAMS::CHAR-DECODER
;     (LOCALLY
;      (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
;      (FLET ((#:GET-CHAR-CODE4 #
;               #))
;        (LET (#)
;          (CASE #:CHAR-CODE2 # #)))))
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER NIL). Use GO/RETURN-FROM with SAFETY 0, or declare
; the exit function DYNAMIC-EXTENT to avoid.
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER
;   (RECOVER-FROM-ENCODING-ERROR FORMAT
;    "Unexpected value #x~X at start of UTF-8 sequence." OCTET)).
; Use GO/RETURN-FROM with SAFETY 0, or declare the exit function DYNAMIC-EXTENT
; to avoid.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET 
; ==>
;   (BLOCK FLEXI-STREAMS::CHAR-DECODER
;     (LOCALLY
;      (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
;      (FLET ((#:GET-CHAR-CODE4 #
;               #))
;        (LET (#)
;          (CASE #:CHAR-CODE2 # #)))))
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER NIL). Use GO/RETURN-FROM with SAFETY 0, or declare
; the exit function DYNAMIC-EXTENT to avoid.
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER
;   (RECOVER-FROM-ENCODING-ERROR FORMAT
;    "Unexpected value #x~X at start of UTF-8 sequence." OCTET)).
; Use GO/RETURN-FROM with SAFETY 0, or declare the exit function DYNAMIC-EXTENT
; to avoid.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET 
; ==>
;   (BLOCK FLEXI-STREAMS::CHAR-DECODER
;     (LOCALLY
;      (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
;      (FLET ((#:GET-CHAR-CODE4 #
;               #))
;        (LET (#)
;          (CASE #:CHAR-CODE2 # #)))))
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER NIL). Use GO/RETURN-FROM with SAFETY 0, or declare
; the exit function DYNAMIC-EXTENT to avoid.
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER
;   (RECOVER-FROM-ENCODING-ERROR FORMAT
;    "Unexpected value #x~X at start of UTF-8 sequence." OCTET)).
; Use GO/RETURN-FROM with SAFETY 0, or declare the exit function DYNAMIC-EXTENT
; to avoid.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL &OPTIONAL), not a (MOD 1114112).
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; 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.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-8-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-8-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-8-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (FLET (#)
;             (LET #
;               #
;               #)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-FLOAT numeric operation
; due to type uncertainty:
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-(COMPLEX FLOAT) numeric operation
; due to type uncertainty:
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER NIL). Use GO/RETURN-FROM with SAFETY 0, or declare
; the exit function DYNAMIC-EXTENT to avoid.
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (NOT NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; processing (DEFINE-CHAR-DECODERS (FLEXI-UTF-16-LE-FORMAT FLEXI-CR-UTF-16-LE-FORMAT ...) ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/decode.lisp
; in:
;      DEFINE-CHAR-DECODERS (FLEXI-UTF-16-LE-FORMAT FLEXI-CR-UTF-16-LE-FORMAT
;                        FLEXI-CRLF-UTF-16-LE-FORMAT)
;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROG1 LET OR LET IF COND IF THE RETURN-FROM 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   This is not a (MOD 1114112):
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; 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.

; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER AND IF PROG1 LET THE 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::I)
; 
; 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.

; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROG1 LET OR LET IF COND IF THE RETURN-FROM 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   This is not a (MOD 1114112):
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; 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.

; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER AND IF PROG1 LET THE 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::I)
; 
; 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.

; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-16-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-16-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-16-LE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (FLET (#)
;             (DECLARE #)
;             (LET #
;               #
;               #)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET 
; ==>
;   (BLOCK FLEXI-STREAMS::CHAR-DECODER
;     (LOCALLY
;      (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
;      (FLET ((#:GET-CHAR-CODE4 #
;               #))
;        (LET (#)
;          (CASE #:CHAR-CODE2 # #)))))
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER
;   (RECOVER-FROM-ENCODING-ERROR FORMAT
;    "End of data while in UTF-16 sequence.")).
; Use GO/RETURN-FROM with SAFETY 0, or declare the exit function DYNAMIC-EXTENT
; to avoid.
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER NIL). Use GO/RETURN-FROM with SAFETY 0, or declare
; the exit function DYNAMIC-EXTENT to avoid.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET 
; ==>
;   (BLOCK FLEXI-STREAMS::CHAR-DECODER
;     (LOCALLY
;      (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
;      (FLET ((#:GET-CHAR-CODE4 #
;               #))
;        (LET (#)
;          (CASE #:CHAR-CODE2 # #)))))
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER
;   (RECOVER-FROM-ENCODING-ERROR FORMAT
;    "End of data while in UTF-16 sequence.")).
; Use GO/RETURN-FROM with SAFETY 0, or declare the exit function DYNAMIC-EXTENT
; to avoid.
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER NIL). Use GO/RETURN-FROM with SAFETY 0, or declare
; the exit function DYNAMIC-EXTENT to avoid.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET 
; ==>
;   (BLOCK FLEXI-STREAMS::CHAR-DECODER
;     (LOCALLY
;      (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
;      (FLET ((#:GET-CHAR-CODE4 #
;               #))
;        (LET (#)
;          (CASE #:CHAR-CODE2 # #)))))
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER
;   (RECOVER-FROM-ENCODING-ERROR FORMAT
;    "End of data while in UTF-16 sequence.")).
; Use GO/RETURN-FROM with SAFETY 0, or declare the exit function DYNAMIC-EXTENT
; to avoid.
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER NIL). Use GO/RETURN-FROM with SAFETY 0, or declare
; the exit function DYNAMIC-EXTENT to avoid.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; --> PROG1 LET OR LET IF COND IF THE 
; ==>
;   (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL &OPTIONAL), not a (MOD 1114112).
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; 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.

; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER AND IF PROG1 LET THE 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::I)
; 
; 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.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-16-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-16-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-16-LE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (FLET (#)
;             (DECLARE #)
;             (LET #
;               #
;               #)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-FLOAT numeric operation
; due to type uncertainty:
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-(COMPLEX FLOAT) numeric operation
; due to type uncertainty:
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER
;   (RECOVER-FROM-ENCODING-ERROR FORMAT
;    "End of data while in UTF-16 sequence.")).
; Use GO/RETURN-FROM with SAFETY 0, or declare the exit function DYNAMIC-EXTENT
; to avoid.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; processing (DEFINE-CHAR-DECODERS (FLEXI-UTF-16-BE-FORMAT FLEXI-CR-UTF-16-BE-FORMAT ...) ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/decode.lisp
; in:
;      DEFINE-CHAR-DECODERS (FLEXI-UTF-16-BE-FORMAT FLEXI-CR-UTF-16-BE-FORMAT
;                        FLEXI-CRLF-UTF-16-BE-FORMAT)
;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROG1 LET OR LET IF COND IF THE RETURN-FROM 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   This is not a (MOD 1114112):
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; 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.

; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER AND IF PROG1 LET THE 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::I)
; 
; 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.

; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROG1 LET OR LET IF COND IF THE RETURN-FROM 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   This is not a (MOD 1114112):
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; 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.

; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER AND IF PROG1 LET THE 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::I)
; 
; 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.

; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-16-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-16-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-16-BE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (FLET (#)
;             (DECLARE #)
;             (LET #
;               #
;               #)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET 
; ==>
;   (BLOCK FLEXI-STREAMS::CHAR-DECODER
;     (LOCALLY
;      (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
;      (FLET ((#:GET-CHAR-CODE4 #
;               #))
;        (LET (#)
;          (CASE #:CHAR-CODE2 # #)))))
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER
;   (RECOVER-FROM-ENCODING-ERROR FORMAT
;    "End of data while in UTF-16 sequence.")).
; Use GO/RETURN-FROM with SAFETY 0, or declare the exit function DYNAMIC-EXTENT
; to avoid.
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER NIL). Use GO/RETURN-FROM with SAFETY 0, or declare
; the exit function DYNAMIC-EXTENT to avoid.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET 
; ==>
;   (BLOCK FLEXI-STREAMS::CHAR-DECODER
;     (LOCALLY
;      (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
;      (FLET ((#:GET-CHAR-CODE4 #
;               #))
;        (LET (#)
;          (CASE #:CHAR-CODE2 # #)))))
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER
;   (RECOVER-FROM-ENCODING-ERROR FORMAT
;    "End of data while in UTF-16 sequence.")).
; Use GO/RETURN-FROM with SAFETY 0, or declare the exit function DYNAMIC-EXTENT
; to avoid.
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER NIL). Use GO/RETURN-FROM with SAFETY 0, or declare
; the exit function DYNAMIC-EXTENT to avoid.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET 
; ==>
;   (BLOCK FLEXI-STREAMS::CHAR-DECODER
;     (LOCALLY
;      (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
;      (FLET ((#:GET-CHAR-CODE4 #
;               #))
;        (LET (#)
;          (CASE #:CHAR-CODE2 # #)))))
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER
;   (RECOVER-FROM-ENCODING-ERROR FORMAT
;    "End of data while in UTF-16 sequence.")).
; Use GO/RETURN-FROM with SAFETY 0, or declare the exit function DYNAMIC-EXTENT
; to avoid.
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER NIL). Use GO/RETURN-FROM with SAFETY 0, or declare
; the exit function DYNAMIC-EXTENT to avoid.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; --> PROG1 LET OR LET IF COND IF THE 
; ==>
;   (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL &OPTIONAL), not a (MOD 1114112).
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; 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.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-16-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-16-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-16-BE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (FLET (#)
;             (DECLARE #)
;             (LET #
;               #
;               #)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-FLOAT numeric operation
; due to type uncertainty:
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-(COMPLEX FLOAT) numeric operation
; due to type uncertainty:
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER AND IF PROG1 LET THE 
; ==>
;   (AREF SEQUENCE FLEXI-STREAMS::I)
; 
; 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.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-16-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-16-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-16-BE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (FLET (#)
;             (DECLARE #)
;             (LET #
;               #
;               #)))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER
;   (RECOVER-FROM-ENCODING-ERROR FORMAT
;    "End of data while in UTF-16 sequence.")).
; Use GO/RETURN-FROM with SAFETY 0, or declare the exit function DYNAMIC-EXTENT
; to avoid.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; processing (DEFINE-CHAR-DECODERS (FLEXI-UTF-32-LE-FORMAT FLEXI-CR-UTF-32-LE-FORMAT ...) ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/decode.lisp
; in:
;      DEFINE-CHAR-DECODERS (FLEXI-UTF-32-LE-FORMAT FLEXI-CR-UTF-32-LE-FORMAT
;                        FLEXI-CRLF-UTF-32-LE-FORMAT)
;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-16 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET 
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK SYMBOL-MACROLET LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET 
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK SYMBOL-MACROLET LET WHEN IF AND IF OR LET 
; --> IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-124 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-139 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-107 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; 
; caught STYLE-WARNING:
;   This is not a (MOD 1114112):
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-464 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET PROGN LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET PROGN LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-480 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-446 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; 
; caught STYLE-WARNING:
;   This is not a (MOD 1114112):
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET 
; ==>
;   (BLOCK FLEXI-STREAMS::CHAR-DECODER
;     (LOCALLY
;      (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
;      (FLET ((#:GET-CHAR-CODE4 #
;               #))
;        (LET (#)
;          (CASE #:CHAR-CODE2 # #)))))
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER NIL). Use GO/RETURN-FROM with SAFETY 0, or declare
; the exit function DYNAMIC-EXTENT to avoid.
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER
;   (RECOVER-FROM-ENCODING-ERROR FORMAT
;    "End of data while in UTF-32 sequence.")).
; Use GO/RETURN-FROM with SAFETY 0, or declare the exit function DYNAMIC-EXTENT
; to avoid.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET 
; ==>
;   (BLOCK FLEXI-STREAMS::CHAR-DECODER
;     (LOCALLY
;      (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
;      (FLET ((#:GET-CHAR-CODE4 #
;               #))
;        (LET (#)
;          (CASE #:CHAR-CODE2 # #)))))
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER NIL). Use GO/RETURN-FROM with SAFETY 0, or declare
; the exit function DYNAMIC-EXTENT to avoid.
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER
;   (RECOVER-FROM-ENCODING-ERROR FORMAT
;    "End of data while in UTF-32 sequence.")).
; Use GO/RETURN-FROM with SAFETY 0, or declare the exit function DYNAMIC-EXTENT
; to avoid.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET 
; ==>
;   (BLOCK FLEXI-STREAMS::CHAR-DECODER
;     (LOCALLY
;      (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
;      (FLET ((#:GET-CHAR-CODE4 #
;               #))
;        (LET (#)
;          (CASE #:CHAR-CODE2 # #)))))
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER NIL). Use GO/RETURN-FROM with SAFETY 0, or declare
; the exit function DYNAMIC-EXTENT to avoid.
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER
;   (RECOVER-FROM-ENCODING-ERROR FORMAT
;    "End of data while in UTF-32 sequence.")).
; Use GO/RETURN-FROM with SAFETY 0, or declare the exit function DYNAMIC-EXTENT
; to avoid.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-791 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-810 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-827 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL &OPTIONAL), not a (MOD 1114112).
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-FLOAT numeric operation
; due to type uncertainty:
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-(COMPLEX FLOAT) numeric operation
; due to type uncertainty:
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER NIL). Use GO/RETURN-FROM with SAFETY 0, or declare
; the exit function DYNAMIC-EXTENT to avoid.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-LE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-LE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 0 FLEXI-STREAMS::TO 24 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; processing (DEFINE-CHAR-DECODERS (FLEXI-UTF-32-BE-FORMAT FLEXI-CR-UTF-32-BE-FORMAT ...) ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/decode.lisp
; in:
;      DEFINE-CHAR-DECODERS (FLEXI-UTF-32-BE-FORMAT FLEXI-CR-UTF-32-BE-FORMAT
;                        FLEXI-CRLF-UTF-32-BE-FORMAT)
;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-16 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET 
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK SYMBOL-MACROLET LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET 
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK SYMBOL-MACROLET LET WHEN IF AND IF OR LET 
; --> IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-124 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-139 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-107 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; 
; caught STYLE-WARNING:
;   This is not a (MOD 1114112):
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-464 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET PROGN LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY LET PROGN LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-480 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> LET PROGN LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-446 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; 
; caught STYLE-WARNING:
;   This is not a (MOD 1114112):
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; --> PROG1 LET OR LET FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET 
; ==>
;   (AREF (THE (ARRAY FLEXI-STREAMS:OCTET *) FLEXI-STREAMS::BUFFER)
;         FLEXI-STREAMS::BUFFER-POS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY *
;                                                              (*)).
; 
; note: unable to
;   avoid runtime dispatch on array element type
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET 
; ==>
;   (BLOCK FLEXI-STREAMS::CHAR-DECODER
;     (LOCALLY
;      (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
;      (FLET ((#:GET-CHAR-CODE4 #
;               #))
;        (LET (#)
;          (CASE #:CHAR-CODE2 # #)))))
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER NIL). Use GO/RETURN-FROM with SAFETY 0, or declare
; the exit function DYNAMIC-EXTENT to avoid.
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER
;   (RECOVER-FROM-ENCODING-ERROR FORMAT
;    "End of data while in UTF-32 sequence.")).
; Use GO/RETURN-FROM with SAFETY 0, or declare the exit function DYNAMIC-EXTENT
; to avoid.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET 
; ==>
;   (BLOCK FLEXI-STREAMS::CHAR-DECODER
;     (LOCALLY
;      (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
;      (FLET ((#:GET-CHAR-CODE4 #
;               #))
;        (LET (#)
;          (CASE #:CHAR-CODE2 # #)))))
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER NIL). Use GO/RETURN-FROM with SAFETY 0, or declare
; the exit function DYNAMIC-EXTENT to avoid.
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER
;   (RECOVER-FROM-ENCODING-ERROR FORMAT
;    "End of data while in UTF-32 sequence.")).
; Use GO/RETURN-FROM with SAFETY 0, or declare the exit function DYNAMIC-EXTENT
; to avoid.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET 
; ==>
;   (BLOCK FLEXI-STREAMS::CHAR-DECODER
;     (LOCALLY
;      (DECLARE (OPTIMIZE SPEED (SPACE 0) (DEBUG 1) (COMPILATION-SPEED 0)))
;      (FLET ((#:GET-CHAR-CODE4 #
;               #))
;        (LET (#)
;          (CASE #:CHAR-CODE2 # #)))))
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER NIL). Use GO/RETURN-FROM with SAFETY 0, or declare
; the exit function DYNAMIC-EXTENT to avoid.
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER
;   (RECOVER-FROM-ENCODING-ERROR FORMAT
;    "End of data while in UTF-32 sequence.")).
; Use GO/RETURN-FROM with SAFETY 0, or declare the exit function DYNAMIC-EXTENT
; to avoid.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF IF PROGN FLEXI-STREAMS::ITERATE 
; --> FLET LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK 
; --> LOCALLY FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-827 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-791 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET 
; ==>
;   (<= 216 (FLEXI-STREAMS::LOGAND* 255 (FLEXI-STREAMS::ASH* #:CHAR-CODE0 -8))
;       223)
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.

; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK WITH-ACCESSORS LET SYMBOL-MACROLET LET* 
; --> FLET MACROLET ETYPECASE LET COND IF IF PROGN FLEXI-STREAMS::ITERATE FLET 
; --> LOOP BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY 
; --> FLET #:GET-CHAR-CODE4 BLOCK LET WHEN IF AND IF OR LET IF > IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; --> BLOCK LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-810 (FLEXI-STREAMS::ASH* FLEXI-STREAMS:OCTET COUNT))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::READ-NEXT-BYTE)
; 
; caught STYLE-WARNING:
;   Result is a (VALUES NULL &OPTIONAL), not a (MOD 1114112).
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-FLOAT numeric operation
; due to type uncertainty:
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-(COMPLEX FLOAT) numeric operation
; due to type uncertainty:
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: Allocating a value-cell at runtime for checking possibly out of extent exit via
; (RETURN-FROM CHAR-DECODER NIL). Use GO/RETURN-FROM with SAFETY 0, or declare
; the exit function DYNAMIC-EXTENT to avoid.

;     (LOOP FLEXI-STREAMS::FOR
;           COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;           FLEXI-STREAMS::FOR ...)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-UTF-32-BE-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-UTF-32-BE-FORMAT)
;       (LET (FLEXI-STREAMS::FIRST-OCTET-SEEN)
;         (DECLARE (BOOLEAN FLEXI-STREAMS::FIRST-OCTET-SEEN))
;         (MACROLET ((FLEXI-STREAMS::READ-NEXT-BYTE #
;                      '#))
;           (LOOP FLEXI-STREAMS::FOR
;                 COUNT FLEXI-STREAMS::OF-TYPE FIXNUM FLEXI-STREAMS::FROM 24 FLEXI-STREAMS::DOWNTO 0 FLEXI-STREAMS::BY 8
;                 FLEXI-STREAMS::FOR ...))))
; --> PROGN FLEXI-STREAMS::DEFINE-SEQUENCE-READERS PROGN DEFMETHOD PROGN 
; --> EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* 
; --> LOCALLY SYMBOL-MACROLET BLOCK LET* LOOP BLOCK LET TAGBODY SETF 
; ==>
;   (SB-KERNEL:%SCHARSET STRING FLEXI-STREAMS::J
;                        (CODE-CHAR
;                         (MACROLET ((FLEXI-STREAMS::UNGET #
;                                      `#))
;                           (SYMBOL-MACROLET (#)
;                             (BLOCK FLEXI-STREAMS::CHAR-DECODER #)))))
; 
; 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 result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; processing (DEFMETHOD OCTETS-TO-CHAR-CODE ...)
; processing (DEFMETHOD OCTETS-TO-CHAR-CODE ...)

; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/decode-tmp9KKTJMYV.fasl
; compilation finished in 0:00:02.544
WARNING:
   Lisp compilation had style-warnings while
   compiling #<CL-SOURCE-FILE "flexi-streams" "decode">
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/in-memory.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS)
; processing (DEFCLASS IN-MEMORY-STREAM ...)
; processing (DEFCLASS IN-MEMORY-INPUT-STREAM ...)
; processing (DEFCLASS IN-MEMORY-OUTPUT-STREAM ...)
; processing (DEFCLASS LIST-STREAM ...)
; processing (DEFCLASS VECTOR-STREAM ...)
; processing (DEFCLASS LIST-INPUT-STREAM ...)
; processing (DEFCLASS VECTOR-INPUT-STREAM ...)
; processing (DEFCLASS VECTOR-OUTPUT-STREAM ...)
; processing (DEFMETHOD CHECK-IF-OPEN ...)
; processing (DEFMETHOD STREAM-ELEMENT-TYPE ...)
; processing (DEFGENERIC PEEK-BYTE ...)
; processing (DEFMETHOD PEEK-BYTE ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/in-memory.lisp
; in: DEFMETHOD PEEK-BYTE (VECTOR-INPUT-STREAM)
;     (= BYTE FLEXI-STREAMS::PEEK-TYPE)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR BYTE = (READ-BYTE STREAM FLEXI-STREAMS::EOF-ERROR-P :EOF)
;           :FOR FLEXI-STREAMS::NEW-INDEX :FROM FLEXI-STREAMS::INDEX
;           :UNTIL (COND ((EQ BYTE :EOF) (RETURN FLEXI-STREAMS::EOF-VALUE))
;                        ((NULL FLEXI-STREAMS::PEEK-TYPE))
;                        ((EQ FLEXI-STREAMS::PEEK-TYPE 'T) (PLUSP BYTE))
;                        ((= BYTE FLEXI-STREAMS::PEEK-TYPE)))
;           :FINALLY ...)
; --> BLOCK LET LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 
; ==>
;   (1+ FLEXI-STREAMS::NEW-INDEX)
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PLUSP BYTE)
; 
; note: forced to do FAST-IF->-ZERO (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (LOOP :FOR BYTE = (READ-BYTE STREAM FLEXI-STREAMS::EOF-ERROR-P :EOF)
;           :FOR FLEXI-STREAMS::NEW-INDEX :FROM FLEXI-STREAMS::INDEX
;           :UNTIL (COND ((EQ BYTE :EOF) (RETURN FLEXI-STREAMS::EOF-VALUE))
;                        ((NULL FLEXI-STREAMS::PEEK-TYPE))
;                        ((EQ FLEXI-STREAMS::PEEK-TYPE 'T) (PLUSP BYTE))
;                        ((= BYTE FLEXI-STREAMS::PEEK-TYPE)))
;           :FINALLY ...)
; --> BLOCK LET LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 
; ==>
;   (1+ FLEXI-STREAMS::NEW-INDEX)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; processing (DEFMETHOD PEEK-BYTE ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/in-memory.lisp
; in: DEFMETHOD PEEK-BYTE (LIST-INPUT-STREAM)
;     (= BYTE FLEXI-STREAMS::PEEK-TYPE)
; 
; note: unable to open code because: The operands might not be the same type.

;     (PLUSP BYTE)
; 
; note: forced to do FAST-IF->-ZERO (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; processing (DEFMETHOD TRANSFORM-OCTET ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/in-memory.lisp
; in: DEFMETHOD TRANSFORM-OCTET (IN-MEMORY-STREAM T)
;     (FUNCALL (OR (FLEXI-STREAMS::IN-MEMORY-STREAM-TRANSFORMER STREAM) #'IDENTITY)
;              FLEXI-STREAMS:OCTET)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   callable expression is not known to be a function

; processing (DEFMETHOD STREAM-READ-BYTE ...)
; processing (DEFMETHOD STREAM-LISTEN ...)
; processing (DEFMETHOD STREAM-READ-SEQUENCE ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/in-memory.lisp
; in: DEFMETHOD STREAM-READ-SEQUENCE (LIST-INPUT-STREAM T T T)
;     (SETF (ELT SEQUENCE FLEXI-STREAMS::INDEX) (POP LIST))
; ==>
;   (SB-KERNEL:%SETELT SEQUENCE FLEXI-STREAMS::INDEX (POP LIST))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.

; processing (DEFMETHOD STREAM-READ-BYTE ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/in-memory.lisp
; in: DEFMETHOD STREAM-READ-BYTE (VECTOR-INPUT-STREAM)
;     (AREF VECTOR FLEXI-STREAMS::CURRENT-INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

; processing (DEFMETHOD STREAM-LISTEN ...)
; processing (DEFMETHOD STREAM-READ-SEQUENCE ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/in-memory.lisp
; in: DEFMETHOD STREAM-READ-SEQUENCE (VECTOR-INPUT-STREAM T T T)
;     (AREF VECTOR FLEXI-STREAMS::VECTOR-INDEX)
; 
; note: unable to
;   optimize
; because:
;   Upgraded element type of array is not known at compile time.

;     (SETF (ELT SEQUENCE FLEXI-STREAMS::INDEX)
;             (AREF VECTOR FLEXI-STREAMS::VECTOR-INDEX))
; ==>
;   (SB-KERNEL:%SETELT SEQUENCE FLEXI-STREAMS::INDEX
;                      (AREF VECTOR FLEXI-STREAMS::VECTOR-INDEX))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.

; processing (DEFMETHOD STREAM-WRITE-BYTE ...)
; processing (DEFMETHOD STREAM-WRITE-SEQUENCE ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/in-memory.lisp
; in: DEFMETHOD STREAM-WRITE-SEQUENCE (VECTOR-OUTPUT-STREAM T T T)
;     (ELT SEQUENCE FLEXI-STREAMS::INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.

; processing (DEFMETHOD STREAM-FILE-POSITION ...)
; processing (DEFMETHOD (SETF STREAM-FILE-POSITION) ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/in-memory.lisp
; in: DEFMETHOD (SETF STREAM-FILE-POSITION) (T VECTOR-INPUT-STREAM)
;     (<= 0 FLEXI-STREAMS::POSITION-SPEC FLEXI-STREAMS::END)
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: forced to do FAST-IF-<-ZERO (cost 9)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

; processing (DEFMETHOD STREAM-FILE-POSITION ...)
; processing (DEFMETHOD (SETF STREAM-FILE-POSITION) ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/in-memory.lisp
; in: DEFMETHOD (SETF STREAM-FILE-POSITION) (T VECTOR-OUTPUT-STREAM)
;     (ARRAY-TOTAL-SIZE VECTOR)
; 
; note: unable to optimize because: can't tell the rank at compile time

;     (<= 0 FLEXI-STREAMS::POSITION-SPEC ARRAY-TOTAL-SIZE-LIMIT)
; 
; note: forced to do FAST-IF-<-ZERO (cost 9)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       etc.

; processing (DEFMETHOD MAKE-IN-MEMORY-INPUT-STREAM ...)
; processing (DEFMETHOD MAKE-IN-MEMORY-INPUT-STREAM ...)
; processing (DEFUN MAKE-OUTPUT-VECTOR ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/in-memory.lisp
; in: DEFUN MAKE-OUTPUT-VECTOR
;     (MAKE-ARRAY 0 :ADJUSTABLE T :FILL-POINTER 0 :ELEMENT-TYPE
;                 FLEXI-STREAMS::ELEMENT-TYPE)
; 
; note: unable to optimize because: ELEMENT-TYPE is not constant.

; processing (DEFUN MAKE-IN-MEMORY-OUTPUT-STREAM ...)
; processing (DEFMETHOD GET-OUTPUT-STREAM-SEQUENCE ...)
; processing (DEFMETHOD OUTPUT-STREAM-SEQUENCE-LENGTH ...)
; processing (DEFMACRO WITH-INPUT-FROM-SEQUENCE ...)
; processing (DEFMACRO WITH-OUTPUT-TO-SEQUENCE ...)

; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/in-memory-tmpJU0JWO19.fasl
; compilation finished in 0:00:00.092
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/stream.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS)
; processing (DEFCLASS FLEXI-STREAM ...)
; processing (DEFMETHOD INITIALIZE-INSTANCE ...)
; processing (DEFMETHOD (SETF FLEXI-STREAM-EXTERNAL-FORMAT) ...)
; processing (DEFMETHOD (SETF FLEXI-STREAM-ELEMENT-TYPE) ...)
; processing (DEFMETHOD STREAM-ELEMENT-TYPE ...)
; processing (DEFMETHOD CLOSE ...)
; processing (DEFMETHOD OPEN-STREAM-P ...)
; processing (DEFMETHOD STREAM-FILE-POSITION ...)
; processing (DEFMETHOD (SETF STREAM-FILE-POSITION) ...)
; processing (DEFCLASS FLEXI-OUTPUT-STREAM ...)
; processing (DEFCLASS FLEXI-INPUT-STREAM ...)
; processing (DEFCLASS FLEXI-IO-STREAM ...)
; processing (DEFUN MAKE-FLEXI-STREAM ...)

; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/stream-tmpZX2WN8N4.fasl
; compilation finished in 0:00:00.032
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/output.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS)
; processing (DEFGENERIC WRITE-BYTE* ...)
; processing (DEFMETHOD WRITE-BYTE* ...)
; processing (DEFMETHOD STREAM-WRITE-CHAR ...)
; processing (DEFMETHOD STREAM-WRITE-CHAR ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/output.lisp
; in: DEFMETHOD STREAM-WRITE-CHAR :AFTER (FLEXI-OUTPUT-STREAM T)
;     (INCF (THE INTEGER FLEXI-STREAMS::COLUMN))
; --> LET* 
; ==>
;   (+ 1 (THE INTEGER (FLEXI-STREAMS:FLEXI-STREAM-COLUMN #:G68)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; processing (DEFMETHOD STREAM-CLEAR-OUTPUT ...)
; processing (DEFMETHOD STREAM-FINISH-OUTPUT ...)
; processing (DEFMETHOD STREAM-FORCE-OUTPUT ...)
; processing (DEFMETHOD STREAM-LINE-COLUMN ...)
; processing (DEFMETHOD STREAM-WRITE-BYTE ...)
; processing (DEFMETHOD STREAM-WRITE-SEQUENCE ...)
; processing (DEFMETHOD STREAM-WRITE-STRING ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/output.lisp
; in: DEFMETHOD STREAM-WRITE-STRING (FLEXI-OUTPUT-STREAM T)
;     (LENGTH STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.


; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/output-tmpOU81XRV0.fasl
; compilation finished in 0:00:00.024
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/input.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS)
; processing (DEFMETHOD READ-BYTE* ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/input.lisp
; in: DEFMETHOD READ-BYTE* (FLEXI-INPUT-STREAM)
;     (AND FLEXI-STREAMS::BOUND (>= POSITION FLEXI-STREAMS::BOUND))
; --> IF 
; ==>
;   (>= (THE INTEGER POSITION) (THE (OR NULL INTEGER) FLEXI-STREAMS::BOUND))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.

;     (INCF POSITION)
; --> LET* 
; ==>
;   (+ 1 (THE INTEGER (FLEXI-STREAMS:FLEXI-STREAM-POSITION #:G08)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (DECF POSITION)
; --> LET* 
; ==>
;   (SB-IMPL::XSUBTRACT 1
;                       (THE INTEGER
;                            (FLEXI-STREAMS:FLEXI-STREAM-POSITION #:G012)))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; processing (DEFMETHOD STREAM-CLEAR-INPUT ...)
; processing (DEFMETHOD STREAM-LISTEN ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/input.lisp
; in: DEFMETHOD STREAM-LISTEN (FLEXI-INPUT-STREAM)
;     (AND FLEXI-STREAMS::BOUND (>= POSITION FLEXI-STREAMS::BOUND))
; --> IF 
; ==>
;   (>= (THE INTEGER POSITION) (THE (OR NULL INTEGER) FLEXI-STREAMS::BOUND))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.

; processing (DEFMETHOD STREAM-READ-BYTE ...)
; processing (DEFUN UNREAD-CHAR% ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/input.lisp
; in: DEFUN UNREAD-CHAR%
;     (DECF POSITION FLEXI-STREAMS::COUNTER)
; --> LET* 
; ==>
;   (SB-IMPL::XSUBTRACT FLEXI-STREAMS::COUNTER
;                       (FLEXI-STREAMS:FLEXI-STREAM-POSITION #:G01))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64)
;                                                                &REST T).
;       etc.

; processing (DEFMETHOD STREAM-READ-CHAR ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/input.lisp
; in: DEFMETHOD STREAM-READ-CHAR (FLEXI-INPUT-STREAM)
;     (OR (CODE-CHAR CHAR-CODE) CHAR-CODE)
; --> LET IF 
; ==>
;   CHAR-CODE
; 
; note: deleting unreachable code

; processing (DEFMETHOD STREAM-READ-CHAR-NO-HANG ...)
; processing (DEFMETHOD STREAM-READ-SEQUENCE ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/input.lisp
; in: DEFMETHOD STREAM-READ-SEQUENCE (FLEXI-INPUT-STREAM T T T)
;     (REPLACE SEQUENCE FLEXI-STREAMS::OCTET-STACK :START1 FLEXI-STREAMS::START
;              :END1 FLEXI-STREAMS::END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
;   The second argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING
;                                                              &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY CHARACTER
;                                                        (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        SINGLE-FLOAT (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY DOUBLE-FLOAT (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY DOUBLE-FLOAT (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        DOUBLE-FLOAT (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-BIT-VECTOR.
;   The second argument is a SEQUENCE, not a SIMPLE-BIT-VECTOR.
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES SIMPLE-BIT-VECTOR
;                                                              &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        (UNSIGNED-BYTE 2) (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        (UNSIGNED-BYTE 4) (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        (UNSIGNED-BYTE 7) (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        (UNSIGNED-BYTE 8) (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 15)
;                                             (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        (UNSIGNED-BYTE 15) (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 16)
;                                             (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        (UNSIGNED-BYTE 16) (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 31)
;                                             (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        (UNSIGNED-BYTE 31) (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 32)
;                                             (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        (UNSIGNED-BYTE 32) (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 62) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 62)
;                                             (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        (UNSIGNED-BYTE 62) (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 63) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 63)
;                                             (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        (UNSIGNED-BYTE 63) (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 64) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 64)
;                                             (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        (UNSIGNED-BYTE 64) (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 8) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 8) (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        (SIGNED-BYTE 8) (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 16) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 16) (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        (SIGNED-BYTE 16) (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 32) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 32) (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        (SIGNED-BYTE 32) (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY FIXNUM (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY FIXNUM (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY FIXNUM (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 64) (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 64) (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        (SIGNED-BYTE 64) (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT)
;                                            (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT)
;                                             (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        (COMPLEX SINGLE-FLOAT)
;                                                        (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT)
;                                            (*)).
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT)
;                                             (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY
;                                                        (COMPLEX DOUBLE-FLOAT)
;                                                        (*))
;                                                       &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-VECTOR.
;   The second argument is a SEQUENCE, not a SIMPLE-VECTOR.
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES SIMPLE-VECTOR
;                                                              &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
;   The second argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING
;                                                              &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The second argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
;   The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES
;                                                       (SIMPLE-ARRAY CHARACTER
;                                                        (*))
;                                                       &REST T).

;     (LENGTH FLEXI-STREAMS::OCTET-STACK)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (ELT SEQUENCE (1- FLEXI-STREAMS::INDEX))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.

; processing (DEFMETHOD STREAM-UNREAD-CHAR ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/input.lisp
; in: DEFMETHOD STREAM-UNREAD-CHAR (FLEXI-INPUT-STREAM T)
;     (= (CHAR-CODE CHAR) FLEXI-STREAMS::LAST-CHAR-CODE)
; 
; note: unable to open code because: The operands might not be the same type.

; processing (DEFMETHOD UNREAD-BYTE ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/input.lisp
; in: DEFMETHOD UNREAD-BYTE (T FLEXI-INPUT-STREAM)
;     (= BYTE FLEXI-STREAMS::LAST-OCTET)
; 
; note: unable to
;   open-code float conversion of first argument in mixed SINGLE-FLOAT-DOUBLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed DOUBLE-FLOAT-SINGLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of first argument in mixed SINGLE-FLOAT-(COMPLEX DOUBLE-FLOAT) numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX DOUBLE-FLOAT)-SINGLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       etc.

;     (DECF (THE INTEGER POSITION))
; --> LET* 
; ==>
;   (SB-IMPL::XSUBTRACT 1
;                       (THE INTEGER (FLEXI-STREAMS:FLEXI-STREAM-POSITION #:G79)))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; processing (DEFMETHOD PEEK-BYTE ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/input.lisp
; in: DEFMETHOD PEEK-BYTE (FLEXI-INPUT-STREAM)
;     (= FLEXI-STREAMS:OCTET FLEXI-STREAMS::PEEK-TYPE)
; 
; note: unable to open code because: The operands might not be the same type.

;     (PLUSP FLEXI-STREAMS:OCTET)
; 
; note: forced to do FAST-IF->-ZERO (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.


; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/input-tmpY2ML9CFA.fasl
; compilation finished in 0:00:00.048
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/io.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS)
; processing (DEFMETHOD RESET-INPUT-STATE ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/io.lisp
; in: DEFMETHOD RESET-INPUT-STATE (FLEXI-IO-STREAM)
;     (LENGTH FLEXI-STREAMS::OCTET-STACK)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; processing (DEFMETHOD STREAM-WRITE-BYTE ...)
; processing (DEFMETHOD STREAM-WRITE-CHAR ...)
; processing (DEFMETHOD STREAM-WRITE-SEQUENCE ...)
; processing (DEFMETHOD STREAM-CLEAR-OUTPUT ...)
; processing (DEFMETHOD RESET-OUTPUT-STATE ...)
; processing (DEFMETHOD STREAM-READ-BYTE ...)
; processing (DEFMETHOD STREAM-READ-CHAR ...)
; processing (DEFMETHOD STREAM-READ-SEQUENCE ...)
; processing (DEFMETHOD STREAM-UNREAD-CHAR ...)
; processing (DEFMETHOD UNREAD-BYTE ...)
; processing (DEFMETHOD STREAM-CLEAR-INPUT ...)
; processing (DEFMETHOD WRITE-BYTE* ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/io.lisp
; in: DEFMETHOD WRITE-BYTE* :AFTER (T FLEXI-IO-STREAM)
;     (INCF POSITION)
; --> LET* 
; ==>
;   (+ 1 (FLEXI-STREAMS:FLEXI-STREAM-POSITION #:G56))
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   associate +/(+ -) of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.


; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/io-tmpX2JYJDQE.fasl
; compilation finished in 0:00:00.028
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/strings.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS)
; processing (DEFUN STRING-TO-OCTETS ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/strings.lisp
; in: DEFUN STRING-TO-OCTETS
;     (LENGTH STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; processing (DEFUN OCTETS-TO-STRING ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/strings.lisp
; in: DEFUN OCTETS-TO-STRING
;     (LENGTH SEQUENCE)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; processing (DEFUN OCTET-LENGTH ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/strings.lisp
; in: DEFUN OCTET-LENGTH
;     (LENGTH STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; processing (DEFUN CHAR-LENGTH ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/strings.lisp
; in: DEFUN CHAR-LENGTH
;     (LENGTH SEQUENCE)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.


; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/strings-tmpOPCILR65.fasl
; compilation finished in 0:00:00.016
; 
; compilation unit finished
;   caught 15 STYLE-WARNING conditions
;   printed 1285 notes
phase `build' succeeded after 4.8 seconds
starting phase `check'
Invoking sbcl: "/gnu/store/i8wj59i9x3p8k253jmhxn5hi2iw0x4hw-sbcl-2.1.4/bin/sbcl" "--non-interactive" "--eval" "(require :asdf)" "--eval" "(asdf:load-asd (truename \"/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/flexi-streams.asd\"))" "--eval" "(when (uiop:file-exists-p \"flexi-streams-tests.asd\") (asdf:load-asd (truename \"flexi-streams-tests.asd\")))" "--eval" "(when (uiop:file-exists-p \"flexi-streams-test.asd\") (asdf:load-asd (truename \"flexi-streams-test.asd\")))" "--eval" "(when (uiop:file-exists-p \"tests.asd\") (asdf:load-asd (truename \"tests.asd\")))" "--eval" "(when (uiop:file-exists-p \"test.asd\") (asdf:load-asd (truename \"test.asd\")))" "--eval" "(asdf:test-system \"flexi-streams\")" 
This is SBCL 2.1.4, 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: System definition file #P"/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/flexi-streams.asd" contains definition for system "flexi-streams-test". Please only define "flexi-streams" and secondary systems with a name starting with "flexi-streams/" (e.g. "flexi-streams/test") in that file.
WARNING:
   Deprecated recursive use of (ASDF/OPERATE:OPERATE 'ASDF/LISP-ACTION:LOAD-OP
   '("flexi-streams-test")) while visiting
   (ASDF/LISP-ACTION:TEST-OP "flexi-streams") - please use proper dependencies
   instead
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/test/packages.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :CL-USER)
; processing (DEFPACKAGE :FLEXI-STREAMS-TEST ...)

; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/test/packages-tmpGHU3ALSV.fasl
; compilation finished in 0:00:00.000
; compiling file "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/test/test.lisp" (written 01 JAN 1970 12:00:00 AM):
; processing (IN-PACKAGE :FLEXI-STREAMS-TEST)
; processing (DEFMACRO WITH-TEST-SUITE ...)
; processing (DEFCONSTANT +BUFFER-SIZE+ ...)
; processing (DEFVAR *COPY-FUNCTION* ...)
; processing (DEFVAR *THIS-FILE* ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/test/test.lisp
; in: DEFVAR *THIS-FILE*
;     (OR
;      #P"/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/test/test.lisp"
;      *LOAD-PATHNAME*)
; --> LET IF 
; ==>
;   *LOAD-PATHNAME*
; 
; note: deleting unreachable code

; processing (DEFVAR *TMP-DIR* ...)
; processing (DEFVAR *TEST-FILES* ...)
; processing (DEFUN CREATE-FILE-VARIANTS ...)
; processing (DEFUN CREATE-TEST-COMBINATIONS ...)
; processing (DEFUN FILE-EQUAL ...)
; processing (DEFUN COPY-STREAM ...)
; processing (DEFUN COPY-STREAM* ...)
; processing (DEFUN COPY-FILE ...)
; processing (DEFUN COMPARE-FILES ...)
; processing (DEFUN FILE-AS-OCTET-VECTOR ...)
; processing (DEFUN FILE-AS-STRING ...)
; processing (DEFUN OLD-STRING-TO-OCTETS ...)
; processing (DEFUN OLD-OCTETS-TO-STRING ...)
; file: /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/share/common-lisp/sbcl/flexi-streams/test/test.lisp
; in: DEFUN OLD-OCTETS-TO-STRING
;     (LENGTH VECTOR)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (FLEXI-STREAMS:WITH-INPUT-FROM-SEQUENCE (FLEXI-STREAMS-TEST::IN VECTOR :START
;                                              FLEXI-STREAMS-TEST::START :END
;                                              FLEXI-STREAMS-TEST::END)
;       (LET ((FLEXI-STREAMS-TEST::FLEXI
;              (FLEXI-STREAMS:MAKE-FLEXI-STREAM FLEXI-STREAMS-TEST::IN
;                                               :EXTERNAL-FORMAT
;                                               FLEXI-STREAMS-TEST::EXTERNAL-FORMAT))
;             (FLEXI-STREAMS-TEST::RESULT
;              (MAKE-ARRAY # :ELEMENT-TYPE 'CHARACTER :FILL-POINTER T)))
;         (SETF (FILL-POINTER FLEXI-STREAMS-TEST::RESULT)
;                 (READ-SEQUENCE FLEXI-STREAMS-TEST::RESULT
;                                FLEXI-STREAMS-TEST::FLEXI))
;         FLEXI-STREAMS-TEST::RESULT))
; --> LET LET UNWIND-PROTECT FLET BLOCK BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM 
; --> PROGN SETQ THE FLEXI-STREAMS:MAKE-IN-MEMORY-INPUT-STREAM OR LET IF 
; ==>
;   (LENGTH #:SEQUENCE2)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (- FLEXI-STREAMS-TEST::END FLEXI-STREAMS-TEST::START)
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed FLOAT-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion of first argument in mixed RATIONAL-(COMPLEX FLOAT) numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                              (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX FLOAT)-RATIONAL numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT)
;                                             (COMPLEX DOUBLE-FLOAT)).
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code float conversion of first argument in mixed SINGLE-FLOAT-DOUBLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of second argument in mixed DOUBLE-FLOAT-SINGLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code float conversion of first argument in mixed SINGLE-FLOAT-(COMPLEX DOUBLE-FLOAT) numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   open-code float conversion of second argument in mixed (COMPLEX DOUBLE-FLOAT)-SINGLE-FLOAT numeric operation
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT
;                                                                &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a 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
;                                                                &REST T).
;       etc.

; processing (DEFUN STRING-TESTS ...)
; processing (DEFUN SEQUENCE-EQUAL ...)
; processing (DEFUN SEQUENCE-TESTS ...)
; processing (DEFMACRO USING-VALUES ...)
; processing (DEFUN ACCEPT-OVERLONG ...)
; processing (DEFUN READ-FLEXI-LINE ...)
; processing (DEFUN READ-FLEXI-LINE* ...)
; processing (DEFUN ERROR-HANDLING-TESTS ...)
; processing (DEFUN UNREAD-CHAR-TESTS ...)
; processing (DEFUN COLUMN-TESTS ...)
; processing (DEFUN MAKE-EXTERNAL-FORMAT-TESTS ...)
; processing (DEFUN RUN-ALL-TESTS ...)

; wrote /gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib/common-lisp/sbcl/flexi-streams/test/test-tmpAAURSO1.fasl
; compilation finished in 0:00:00.880
Test suite: "Reading/writing files"
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..
Test suite: "String tests"
..........
..........
.....
Test suite: "Sequence tests"
..........
..........
..........
..........
.......
Test suite: "Testing error handling"
..........
..........
..........
..........
..........
..........
...
Test suite: "UNREAD-CHAR behaviour."
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
......
Test suite: "STREAM-LINE-COLUMN tests"
....
Test suite: "MAKE-EXTERNAL-FORMAT tests"
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
...

; 
; compilation unit finished
;   printed 12 notes
All tests passed.phase `check' succeeded after 13.7 seconds
starting phase `create-asdf-configuration'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/.cl-union/etc/common-lisp/source-registry.conf.d/50-trivial-gray-streams.conf' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/etc/common-lisp/source-registry.conf.d/50-trivial-gray-streams.conf'
`/tmp/guix-build-sbcl-flexi-streams-1.0.18.drv-0/source/.cl-union/etc/common-lisp/asdf-output-translations.conf.d/50-trivial-gray-streams.conf' -> `/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/etc/common-lisp/asdf-output-translations.conf.d/50-trivial-gray-streams.conf'
phase `create-asdf-configuration' succeeded after 0.0 seconds
starting phase `cleanup'
phase `cleanup' succeeded after 0.0 seconds
starting phase `patch-shebangs'
phase `patch-shebangs' succeeded after 0.0 seconds
starting phase `strip'
phase `strip' succeeded after 0.0 seconds
starting phase `validate-runpath'
validating RUNPATH of 0 binaries in "/gnu/store/9fpm23dpmnc4plq1sn9wh8ys8x3f1g2c-sbcl-flexi-streams-1.0.18/lib"...
phase `validate-runpath' succeeded after 0.0 seconds
starting phase `validate-documentation-location'
phase `validate-documentation-location' succeeded after 0.0 seconds
starting phase `delete-info-dir-file'
phase `delete-info-dir-file' succeeded after 0.0 seconds
starting phase `patch-dot-desktop-files'
phase `patch-dot-desktop-files' succeeded after 0.0 seconds
starting phase `install-license-files'
installing 0 license files from '.'
phase `install-license-files' succeeded after 0.0 seconds
starting phase `reset-gzip-timestamps'
phase `reset-gzip-timestamps' succeeded after 0.0 seconds
starting phase `compress-documentation'
phase `compress-documentation' succeeded after 0.0 seconds