; downloaded alexandria from ghcr.io/ocicl/alexandria@sha256:e433c2e076ed3bcf8641b97b00192680db2201d305efac9293539dee88c7fbf7
; downloaded assoc-utils from ghcr.io/ocicl/assoc-utils@sha256:2518d63b253803d35c0c186a4a7801476efc678045c3027252b2e4bfdd4a324b
; downloaded babel from ghcr.io/ocicl/babel@sha256:9d9fcde71acc2b5c39572de4f11756a08c1d8801caa86c581b85dabaa35928b3
; downloaded bordeaux-threads from ghcr.io/ocicl/bordeaux-threads@sha256:bbb32afe3987e102149cc019f4f7366a05f7a37d1503f5f86a27745e671c320a
; downloaded cffi from ghcr.io/ocicl/cffi@sha256:f30662b8a763bd0aff4c0410a5d287aa2c075040a8e5b27007eaa5ea2b70cf02
; downloaded chipz from ghcr.io/ocicl/chipz@sha256:fae0fae0c93199ba57c92d9102245a55c8a2c12af4442e0b141d5670bef4f2f0
; downloaded chunga from ghcr.io/ocicl/chunga@sha256:a2558d54ac5d4ccdbf49d7b51fcb074762d77e263ec67245f6d2928477b6d19a
; downloaded cl-base64 from ghcr.io/ocicl/cl-base64@sha256:702412dbc1ed825e275fb23e22c29527eb786bf644e47c7621bf0dbb34e17c7e
; downloaded cl-fad from ghcr.io/ocicl/cl-fad@sha256:c0aaffc859e419e0a94cedb08f48c2484da404363fb0fe4ffd6e09a80aadafe1
; downloaded cl-json from ghcr.io/ocicl/cl-json@sha256:54c4d00901c2c5b0ea9da11eed8f0104fc5819e1ed9a29d1f3364503a720a868
; downloaded cl-postgres from ghcr.io/ocicl/postmodern@sha256:1575078171b7d86645e492318b5917a578371d1125786f4f43101169e4857cdd
; downloaded cl-ppcre from ghcr.io/ocicl/cl-ppcre@sha256:bf073924cf4fd5957a4fd961a95d446ed0e53fa32a5002cbd2d52182874f45e5
; downloaded cl-qrencode from ghcr.io/ocicl/cl-qrencode@sha256:e581a36606e20879962b842eee5f14eea39ecfa253298e9597ebff44e613f93e
; downloaded cl-smtp from ghcr.io/ocicl/cl-smtp@sha256:214ff22f910dcfff454a10db22c67a0e9d5a7be0ea0e547e27c7efa2cdf5401d
; downloaded closer-mop from ghcr.io/ocicl/closer-mop@sha256:39ec579e68118a8be57a7882812ff31094a031f88b77f11cf4434a92261f1126
; downloaded com.inuoe.jzon from ghcr.io/ocicl/com.inuoe.jzon@sha256:b0cfbc3d8fb3c09526d92575b40b13a68ad93be7edeb48fd69dcea053c5611a5
; downloaded documentation-utils from ghcr.io/ocicl/documentation-utils@sha256:b2a1b3f3bcd1a738af85ae2b0168d408c177661eab6d6bbebb254e394d983f54
; downloaded drakma from ghcr.io/ocicl/drakma@sha256:31c746295d1308c7133f0b7cb64648513bc63c96db02ea8a36be37e32ee5ffe5
; downloaded fiveam from ghcr.io/ocicl/fiveam@sha256:e283043dc8d31e8df2b214465cf5a06ea07bdbea10e600a40e17aaf9518226ac
; downloaded flexi-streams from ghcr.io/ocicl/flexi-streams@sha256:95005b06a8a95c82780c75ead53810bcb273d07fcf5fe76b527f1856df9923f2
; downloaded float-features from ghcr.io/ocicl/float-features@sha256:584413c7c013aa8bad9fc78360e25eb4030c4ad0936f589a5a7c04d33a5f5799
; downloaded frugal-uuid from ghcr.io/ocicl/frugal-uuid@sha256:93f42fd1d2533631fab7bd53d2d6c0ba842fdb678d8c157cdeebae1bdb70afbc
; downloaded global-vars from ghcr.io/ocicl/global-vars@sha256:d197e871c9c9abc4bf31b1186f5fd28f0ca848ebe2e9dddf2d82ecee01dbdc65
; downloaded hunchentoot from ghcr.io/ocicl/hunchentoot@sha256:1dbccc1f9770d3d8917ef87d71720b4ec7f2d6bebf24a3072afca478b00b4427
; downloaded iolib from ghcr.io/ocicl/iolib@sha256:953f1cb142e647da50562d51eca562afc2c5b941b89ae622332b53c7dbed7e1b
; downloaded ironclad from ghcr.io/ocicl/ironclad@sha256:3117e5a26a3e94924074c3548c235a2b733609ed61a2731880ac9e31df55428b
; downloaded iterate from ghcr.io/ocicl/iterate@sha256:6950c55e3782d58cabbbb5753111a70d8cafab8348b7fd6f2143d9abeaab46fb
; downloaded jose from ghcr.io/ocicl/jose@sha256:18ba9617b7ddf58e23b52797b80e63ca8afaa7c5fb44f6671835e3c0639ef8f1
; downloaded md5 from ghcr.io/ocicl/md5@sha256:7d8a8d7af07a2bcbca05ad839555730a0e021c697bf13cc02279669c7a9b038b
; downloaded net.didierverna.asdf-flv from ghcr.io/ocicl/net.didierverna.asdf-flv@sha256:e5cd087d41cf24302a92d9bac426a925f8868b554be2414c0f012c961e3ddb8c
; downloaded pure-tls from ghcr.io/ocicl/pure-tls@sha256:42bc087ee7ea43e0002ddeeac81fc8f136172e5d778d4a67ec7fa2f7d92dacd9
; downloaded puri from ghcr.io/ocicl/puri@sha256:b803fb9444eaf2c7053812e19d342d4ce6a05fd1880fa3a2a2f824769a6d58d2
; downloaded rfc2388 from ghcr.io/ocicl/rfc2388@sha256:4190f6eb36b3b2f53def6eff56b44e76edf4086ada2feb6d88bb671a40fc9f70
; downloaded salza2 from ghcr.io/ocicl/salza2@sha256:0f9d930524b469e1442372a6e12b26742d9e6a1144e6a455006943190d1ea71e
; downloaded split-sequence from ghcr.io/ocicl/split-sequence@sha256:3a37662eedd99c42995587b9d443c4631f25c4c523091bcca31a27b880585b8e
; downloaded sqlite from ghcr.io/ocicl/sqlite@sha256:a7f80757e6ee13af06e2eeaeff1e079dba439d85ea5c7f68e262bccc40dcbd5c
; downloaded trivial-backtrace from ghcr.io/ocicl/trivial-backtrace@sha256:89a3138695bb767c50001402fad60dacfc1e867e4e3d3579cc6f636d3e29a51c
; downloaded trivial-clock from ghcr.io/ocicl/trivial-clock@sha256:0ae7b5e308e5af113b3eed90ca6d96171d229fb953626f90efefad7e75fac98a
; downloaded trivial-features from ghcr.io/ocicl/trivial-features@sha256:e278e24d39060fc7d3715531b16ddd9ab7f93f22ade53e436c0b86dbae3aa065
; downloaded trivial-garbage from ghcr.io/ocicl/trivial-garbage@sha256:a85dcf4110ad60ae9f6c70970acceb2bf12402ce5326891643d35506059afb1d
; downloaded trivial-gray-streams from ghcr.io/ocicl/trivial-gray-streams@sha256:d0cc9fb73876100ee60647524f98b5b22566fa1c3a985d79548b0d2b228f8b51
; downloaded trivial-indent from ghcr.io/ocicl/trivial-indent@sha256:2969bd1dc3cefd22fd1b0c5aeec664d4217a2593fe03bb043d8b6958aabc8b2a
; downloaded trivial-utf-8 from ghcr.io/ocicl/trivial-utf-8@sha256:014e7fa0edd7f351c8b38c3247e0cdda438235bb8a086bb0f2bac08f78ef400d
; downloaded uax-15 from ghcr.io/ocicl/uax-15@sha256:98286ee7b08a849dd2bb8992ab7c4cda7f429f25e8815939297979a49e4b3dad
; downloaded usocket from ghcr.io/ocicl/usocket@sha256:282856b819b22a4319ba30a15605ee934aa23292a471fd29ea4d3f2074b3f16d
; downloaded zpng from ghcr.io/ocicl/zpng@sha256:0796acd47f4c7df74e4525060f77ce906a403030481baf8a46bb38621fb000da

sbcl --non-interactive --eval '(push (truename ".") asdf:*central-registry*)' --eval '(asdf:load-system :usher)' \
        --eval '(format t "~%BUILD-OK~%")'
This is SBCL 2.6.3-1.fc44, 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"/workspace/ocicl/trivial-utf-8-20240503-ba9b4ff/trivial-utf-8.asd" contains definition for system "trivial-utf-8-tests". Please only define "trivial-utf-8" and secondary systems with a name starting with "trivial-utf-8/" (e.g. "trivial-utf-8/test") in that file.
WARNING: System definition file #P"/workspace/ocicl/cl-fad-0.7.6/cl-fad.asd" contains definition for system "cl-fad-test". Please only define "cl-fad" and secondary systems with a name starting with "cl-fad/" (e.g. "cl-fad/test") in that file.
; compiling file "/workspace/ocicl/trivial-features-1.0/src/tf-sbcl.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/trivial-features-1.0/src/tf-sbcl-tmpGHU3ALSV.fasl
; compilation finished in 0:00:00.009
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/package.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/package-tmpAAURSO1.fasl
; compilation finished in 0:00:00.007
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/definitions.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/definitions-tmp5GEXGEG5.fasl
; compilation finished in 0:00:00.014
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/binding.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/binding-tmpAR3FSGEY.fasl
; compilation finished in 0:00:00.028
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/strings.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/strings-tmpJAIDFZTC.fasl
; compilation finished in 0:00:00.003
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/conditions.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/conditions-tmp8V3J6PE9.fasl
; compilation finished in 0:00:00.084
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/symbols.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/symbols-tmp9V47YWQF.fasl
; compilation finished in 0:00:00.032
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/macros.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/macros-tmp9BN22RMA.fasl
; compilation finished in 0:00:00.189
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/functions.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/functions-tmp1CXFJSK9.fasl
; compilation finished in 0:00:00.087
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/lists.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/lists-tmpX4BRKI0R.fasl
; compilation finished in 0:00:00.175
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/types.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/types-tmpQ371UGST.fasl
; compilation finished in 0:00:00.160
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/io.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/io-tmp2OWI3Q7U.fasl
; compilation finished in 0:00:00.208
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/hash-tables.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/hash-tables-tmp9KKTJMYV.fasl
; compilation finished in 0:00:00.079
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/control-flow.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/control-flow-tmpJU0JWO19.fasl
; compilation finished in 0:00:00.068
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/arrays.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/arrays-tmpZX2WN8N4.fasl
; compilation finished in 0:00:00.029
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/sequences.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/sequences.lisp
; in: DEFUN LENGTH=
;     (LENGTH FIRST)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/sequences-tmpOU81XRV0.fasl
; compilation finished in 0:00:00.310
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/numbers.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/numbers-tmpY2ML9CFA.fasl
; compilation finished in 0:00:00.266
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/features.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-1/features-tmpX2JYJDQE.fasl
; compilation finished in 0:00:00.008
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-2/package.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-2/package-tmpOPCILR65.fasl
; compilation finished in 0:00:00.009
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-2/arrays.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-2/arrays-tmpRV9F8A9A.fasl
; compilation finished in 0:00:00.017
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-2/control-flow.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-2/control-flow-tmpK2ZAJT4I.fasl
; compilation finished in 0:00:00.007
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-2/sequences.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-2/sequences-tmpUX5S4ADN.fasl
; compilation finished in 0:00:00.004
; compiling file "/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-2/lists.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/alexandria-20240503-8514d8e/alexandria-2/lists-tmp10401X32.fasl
; compilation finished in 0:00:00.005
; compiling file "/workspace/ocicl/global-vars-20240503-c749f32/global-vars.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/global-vars-20240503-c749f32/global-vars-tmpZ7CBRM0G.fasl
; compilation finished in 0:00:00.026
; compiling file "/workspace/ocicl/trivial-garbage-20240503-3474f64/trivial-garbage.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/trivial-garbage-20240503-3474f64/trivial-garbage-tmp9OZEQ0G2.fasl
; compilation finished in 0:00:00.041
; compiling file "/workspace/ocicl/bordeaux-threads-0.9.4/apiv1/pkgdcl.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/bordeaux-threads-0.9.4/apiv1/pkgdcl-tmpB2JTL1W9.fasl
; compilation finished in 0:00:00.002
; compiling file "/workspace/ocicl/bordeaux-threads-0.9.4/apiv1/bordeaux-threads.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/bordeaux-threads-0.9.4/apiv1/bordeaux-threads-tmpP3BI68WQ.fasl
; compilation finished in 0:00:00.075
; compiling file "/workspace/ocicl/bordeaux-threads-0.9.4/apiv1/impl-sbcl.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/bordeaux-threads-0.9.4/apiv1/impl-sbcl-tmpQDARA81Z.fasl
; compilation finished in 0:00:00.099
; compiling file "/workspace/ocicl/bordeaux-threads-0.9.4/apiv1/default-implementations.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/bordeaux-threads-0.9.4/apiv1/default-implementations-tmpYEMMM7SE.fasl
; compilation finished in 0:00:00.160
; compiling file "/workspace/ocicl/bordeaux-threads-0.9.4/apiv2/pkgdcl.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/bordeaux-threads-0.9.4/apiv2/pkgdcl-tmp73HU0RPK.fasl
; compilation finished in 0:00:00.006
; compiling file "/workspace/ocicl/bordeaux-threads-0.9.4/apiv2/bordeaux-threads.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/bordeaux-threads-0.9.4/apiv2/bordeaux-threads-tmpIO5N7K88.fasl
; compilation finished in 0:00:00.035
; compiling file "/workspace/ocicl/bordeaux-threads-0.9.4/apiv2/timeout-interrupt.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/bordeaux-threads-0.9.4/apiv2/timeout-interrupt-tmpCM21U60Z.fasl
; compilation finished in 0:00:00.002
; compiling file "/workspace/ocicl/bordeaux-threads-0.9.4/apiv2/impl-sbcl.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/bordeaux-threads-0.9.4/apiv2/impl-sbcl-tmp9DT7SEFG.fasl
; compilation finished in 0:00:00.076
; compiling file "/workspace/ocicl/bordeaux-threads-0.9.4/apiv2/atomics.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/bordeaux-threads-0.9.4/apiv2/atomics.lisp
; in: DEFUN ATOMIC-INTEGER-DECF
;     (BT2::ATOMIC-DECF (BT2::ATOMIC-INTEGER-CELL BT2:ATOMIC-INTEGER) BT2::DELTA)
; 
; note: forced to do -/UNSIGNED=>INTEGER (cost 8)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (UNSIGNED-BYTE 64), not a FIXNUM.
;       The second argument is a (UNSIGNED-BYTE 63), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER -9223372036854775807 18446744073709551615)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).

; in: DEFUN ATOMIC-INTEGER-INCF
;     (BT2::ATOMIC-INCF (BT2::ATOMIC-INTEGER-CELL BT2:ATOMIC-INTEGER) BT2::DELTA)
; 
; note: forced to do +/UNSIGNED=>INTEGER (cost 8)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (UNSIGNED-BYTE 64), not a FIXNUM.
;       The second argument is a (UNSIGNED-BYTE 63), not a FIXNUM.
;       The result is a (VALUES (MOD 27670116110564327423) &OPTIONAL), not a (VALUES
;                                                                             FIXNUM
;                                                                             &OPTIONAL).

; in: DEFUN ATOMIC-INTEGER-VALUE
;     (DEFUN BT2:ATOMIC-INTEGER-VALUE (BT2:ATOMIC-INTEGER)
;       "Returns the current value of `ATOMIC-INTEGER`."
;       (DECLARE (TYPE BT2:ATOMIC-INTEGER BT2:ATOMIC-INTEGER)
;                (OPTIMIZE (SAFETY 0) (SPEED 3)))
;       (PROGN (BT2::ATOMIC-INTEGER-CELL BT2:ATOMIC-INTEGER)))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA BT2:ATOMIC-INTEGER-VALUE
;         (BT2:ATOMIC-INTEGER)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       "Returns the current value of `ATOMIC-INTEGER`."
;       (DECLARE (TYPE BT2:ATOMIC-INTEGER BT2:ATOMIC-INTEGER)
;                (OPTIMIZE (SAFETY 0) (SPEED 3)))
;       (BLOCK BT2:ATOMIC-INTEGER-VALUE
;         (PROGN (BT2::ATOMIC-INTEGER-CELL BT2:ATOMIC-INTEGER))))
; 
; note: doing unsigned word to integer coercion (cost 20) to "<return value>"


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/bordeaux-threads-0.9.4/apiv2/atomics-tmp8065ESJT.fasl
; compilation finished in 0:00:00.057
; compiling file "/workspace/ocicl/bordeaux-threads-0.9.4/apiv2/api-locks.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/bordeaux-threads-0.9.4/apiv2/api-locks-tmp7S8Z6FGF.fasl
; compilation finished in 0:00:00.081
; compiling file "/workspace/ocicl/bordeaux-threads-0.9.4/apiv2/api-threads.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/bordeaux-threads-0.9.4/apiv2/api-threads-tmpSIT3QPKP.fasl
; compilation finished in 0:00:00.135
; compiling file "/workspace/ocicl/bordeaux-threads-0.9.4/apiv2/api-semaphores.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/bordeaux-threads-0.9.4/apiv2/api-semaphores-tmpE0PA0714.fasl
; compilation finished in 0:00:00.021
; compiling file "/workspace/ocicl/bordeaux-threads-0.9.4/apiv2/api-condition-variables.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/bordeaux-threads-0.9.4/apiv2/api-condition-variables-tmpJRWHHVG0.fasl
; compilation finished in 0:00:00.016
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/package.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/package-tmp4WZVROCX.fasl
; compilation finished in 0:00:00.020
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/conditions.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/conditions-tmpA0I3UKX8.fasl
; compilation finished in 0:00:00.082
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/generic.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/generic-tmp267Y2N80.fasl
; compilation finished in 0:00:00.018
WARNING: redefining IRONCLAD:BLOCK-LENGTH in DEFGENERIC
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/macro-utils.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/macro-utils-tmpOUPE5FSJ.fasl
; compilation finished in 0:00:00.027
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/util.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/util.lisp
; in: DEFUN BYTE-ARRAY-TO-HEX-STRING
;     (AREF VECTOR IRONCLAD::I)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; in: DEFUN ASCII-STRING-TO-BYTE-ARRAY
;     (CHAR STRING IRONCLAD::I)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/util-tmpIGHCU6ZA.fasl
; compilation finished in 0:00:00.074
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/opt/sbcl/fndb.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/opt/sbcl/fndb-tmpBO0TUGLK.fasl
; compilation finished in 0:00:00.005
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/opt/sbcl/x86oid-vm.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/opt/sbcl/x86oid-vm-tmpIIXPIQNW.fasl
; compilation finished in 0:00:00.294
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/opt/sbcl/cpu-features.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/opt/sbcl/cpu-features-tmpOHM494YR.fasl
; compilation finished in 0:00:00.006
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/common.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/common-tmpOVFB07XF.fasl
; compilation finished in 0:00:00.216
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/cipher.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/cipher-tmpG6VFGMYP.fasl
; compilation finished in 0:00:00.155
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/padding.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/padding-tmp4QIPRMOF.fasl
; compilation finished in 0:00:00.071
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/make-cipher.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/make-cipher-tmpGW0QV22K.fasl
; compilation finished in 0:00:00.067
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/modes.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/modes.lisp
; in: DEFINE-MODE-FUNCTION MODE-CRYPT
;     (IRONCLAD::DEFINE-MODE-FUNCTION IRONCLAD::MODE-CRYPT IRONCLAD::MESSAGE-LENGTH)
; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-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 FLET IRONCLAD::CTR-CRYPT-FUNCTION BLOCK 
; --> IRONCLAD::MODE-LAMBDA LAMBDA FUNCTION LET 
; ==>
;   1
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-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 FLET IRONCLAD::CTR-CRYPT-FUNCTION BLOCK 
; --> IRONCLAD::MODE-LAMBDA LAMBDA FUNCTION LET MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION INCF SETQ THE 
; ==>
;   (+ IRONCLAD::Q IRONCLAD::KEYSTREAM-BLOCKS)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-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 FLET IRONCLAD::CTR-CRYPT-FUNCTION BLOCK 
; --> IRONCLAD::MODE-LAMBDA LAMBDA FUNCTION LET LOOP BLOCK TAGBODY PROGN WHEN 
; --> IF PROGN INCF SETQ THE 
; ==>
;   (+ 1 IRONCLAD::KEYSTREAM-BLOCKS)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-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 FLET IRONCLAD::CTR-CRYPT-FUNCTION BLOCK 
; --> IRONCLAD::MODE-LAMBDA LAMBDA FUNCTION LET 
; ==>
;   1
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-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 FLET IRONCLAD::CTR-CRYPT-FUNCTION BLOCK 
; --> IRONCLAD::MODE-LAMBDA LAMBDA FUNCTION LET MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION INCF SETQ THE 
; ==>
;   (+ IRONCLAD::Q IRONCLAD::KEYSTREAM-BLOCKS)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-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 FLET IRONCLAD::CTR-CRYPT-FUNCTION BLOCK 
; --> IRONCLAD::MODE-LAMBDA LAMBDA FUNCTION LET LOOP BLOCK TAGBODY PROGN WHEN 
; --> IF PROGN INCF SETQ THE 
; ==>
;   (+ 1 IRONCLAD::KEYSTREAM-BLOCKS)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-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 FLET IRONCLAD::CTR-CRYPT-FUNCTION BLOCK 
; --> IRONCLAD::MODE-LAMBDA LAMBDA FUNCTION LET 
; ==>
;   1
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-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 FLET IRONCLAD::CTR-CRYPT-FUNCTION BLOCK 
; --> IRONCLAD::MODE-LAMBDA LAMBDA FUNCTION LET MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION INCF SETQ THE 
; ==>
;   (+ IRONCLAD::Q IRONCLAD::KEYSTREAM-BLOCKS)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-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 FLET IRONCLAD::CTR-CRYPT-FUNCTION BLOCK 
; --> IRONCLAD::MODE-LAMBDA LAMBDA FUNCTION LET LOOP BLOCK TAGBODY PROGN WHEN 
; --> IF PROGN INCF SETQ THE 
; ==>
;   (+ 1 IRONCLAD::KEYSTREAM-BLOCKS)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-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 FLET IRONCLAD::CTR-CRYPT-FUNCTION BLOCK 
; --> IRONCLAD::MODE-LAMBDA LAMBDA FUNCTION LET 
; ==>
;   1
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-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 FLET IRONCLAD::CTR-CRYPT-FUNCTION BLOCK 
; --> IRONCLAD::MODE-LAMBDA LAMBDA FUNCTION LET MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION INCF SETQ THE 
; ==>
;   (+ IRONCLAD::Q IRONCLAD::KEYSTREAM-BLOCKS)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-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 FLET IRONCLAD::CTR-CRYPT-FUNCTION BLOCK 
; --> IRONCLAD::MODE-LAMBDA LAMBDA FUNCTION LET LOOP BLOCK TAGBODY PROGN WHEN 
; --> IF PROGN INCF SETQ THE 
; ==>
;   (+ 1 IRONCLAD::KEYSTREAM-BLOCKS)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-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 FLET IRONCLAD::CTR-CRYPT-FUNCTION BLOCK 
; --> IRONCLAD::MODE-LAMBDA LAMBDA FUNCTION LET 
; ==>
;   1
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-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 FLET IRONCLAD::CTR-CRYPT-FUNCTION BLOCK 
; --> IRONCLAD::MODE-LAMBDA LAMBDA FUNCTION LET MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FUNCTION INCF SETQ THE 
; ==>
;   (+ IRONCLAD::Q IRONCLAD::KEYSTREAM-BLOCKS)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; --> SYMBOL-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 FLET IRONCLAD::CTR-CRYPT-FUNCTION BLOCK 
; --> IRONCLAD::MODE-LAMBDA LAMBDA FUNCTION LET LOOP BLOCK TAGBODY PROGN WHEN 
; --> IF PROGN INCF SETQ THE 
; ==>
;   (+ 1 IRONCLAD::KEYSTREAM-BLOCKS)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/modes-tmp2K9J0HSR.fasl
; compilation finished in 0:00:01.142
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/digest.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/digest-tmpP44I4E0Y.fasl
; compilation finished in 0:00:00.281
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/macs/mac.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/macs/mac-tmp63LQ7EX6.fasl
; compilation finished in 0:00:00.012
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/prng/prng.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/prng/prng-tmp86F1A8FB.fasl
; compilation finished in 0:00:00.031
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/prng/os-prng.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/prng/os-prng-tmpH7D4HL98.fasl
; compilation finished in 0:00:00.008
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/math.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/math.lisp
; in: DEFUN EGCD
;     (= IRONCLAD::C 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (FLOOR IRONCLAD::D IRONCLAD::C)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a FIXNUM.

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

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

;     (* IRONCLAD::Q IRONCLAD::C)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

;     (- IRONCLAD::D (* IRONCLAD::Q IRONCLAD::C))
; 
; 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 REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                              &OPTIONAL).
;       etc.

;     (* IRONCLAD::Q IRONCLAD::U_C)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

;     (- IRONCLAD::U_D (* IRONCLAD::Q IRONCLAD::U_C))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.

;     (* IRONCLAD::Q IRONCLAD::V_C)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

;     (- IRONCLAD::V_D (* IRONCLAD::Q IRONCLAD::V_C))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.

; in: DEFUN JACOBI
;     (REM IRONCLAD::B IRONCLAD::R)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a UNSIGNED-BYTE, not a FIXNUM.

;     (LOGAND IRONCLAD::A 7)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

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

;     (- IRONCLAD::B)
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER * -1), not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       unable to do inline (signed-byte 64) arithmetic (cost 2) because:
;       The first argument is a (INTEGER * -1), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
;                                                              (SIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

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

;     (LOGAND IRONCLAD::B 7)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (ABS IRONCLAD::A)
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER * -1), not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       unable to do inline (signed-byte 64) arithmetic (cost 2) because:
;       The first argument is a (INTEGER * -1), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
;                                                              (SIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER * -1), not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       unable to do inline (signed-byte 64) arithmetic (cost 2) because:
;       The first argument is a (INTEGER * -1), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES
;                                                              (SIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

; in: DEFUN POWER-MOD-TAB
;     (MOD (* IRONCLAD::B IRONCLAD::B) IRONCLAD::M)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a FIXNUM.

;     (MOD (* IRONCLAD::BI IRONCLAD::BB) IRONCLAD::M)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a FIXNUM.

;     (1- IRONCLAD::K)
; 
; 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 INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       etc.

;     (ASH 1 (1- IRONCLAD::K))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline ASH (cost 4) because:
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

;     (* IRONCLAD::B IRONCLAD::B)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

;     (* IRONCLAD::BI IRONCLAD::BB)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

; in: DEFUN POWER-MOD
;     (ZEROP IRONCLAD::E)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

;     (MOD 1 IRONCLAD::M)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a REAL, not a FIXNUM.

;     (MOD (* IRONCLAD::RES IRONCLAD::B) IRONCLAD::M)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a FIXNUM.

;     (MOD (* IRONCLAD::B IRONCLAD::B) IRONCLAD::M)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a FIXNUM.

;     (LDB (BYTE IRONCLAD::TMP IRONCLAD::S) IRONCLAD::E)
; 
; note: unable to
;   convert to inline logical operations
; due to type uncertainty:
;   The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                            (UNSIGNED-BYTE 64)
;                                                            &REST T).

;     (MOD (* IRONCLAD::RES (SVREF IRONCLAD::TAB (ASH IRONCLAD::U -1))) IRONCLAD::M)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a FIXNUM.

;     (MOD (* IRONCLAD::RES IRONCLAD::RES) IRONCLAD::M)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0)))
;                               (RATIONAL 0)), not a SINGLE-FLOAT.
;   The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0)))
;                               (RATIONAL 0)), not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0)))
;                               (RATIONAL 0)), not a INTEGER.
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0)))
;                               (RATIONAL 0)), not a INTEGER.
;   The second argument is a REAL, not a FIXNUM.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0)))
;                               (RATIONAL 0)), not a SINGLE-FLOAT.
;   The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0)))
;                               (RATIONAL 0)), not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0)))
;                               (RATIONAL 0)), not a INTEGER.
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0)))
;                               (RATIONAL 0)), not a INTEGER.
;   The second argument is a REAL, not a FIXNUM.

;     (* IRONCLAD::RES IRONCLAD::B)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

;     (* IRONCLAD::B IRONCLAD::B)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

;     (INTEGER-LENGTH IRONCLAD::E)
; 
; note: forced to do full call
;       unable to do inline (unsigned-byte 64) integer-length (cost 26) because:
;       The first argument is a BIGNUM, not a (UNSIGNED-BYTE 64).

;     (* IRONCLAD::RES IRONCLAD::RES)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0))) (RATIONAL 0))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0))) (RATIONAL 0))
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (DECF IRONCLAD::I)
; --> SB-IMPL::XSUBTRACT BLOCK 
; ==>
;   (- SB-IMPL::B SB-IMPL::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER -1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                      &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER -1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                      &OPTIONAL).
;       etc.

;     (- IRONCLAD::I IRONCLAD::K)
; 
; 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 (INTEGER -7) &OPTIONAL), not a (VALUES FIXNUM
;                                                                      &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER -7) &OPTIONAL), not a (VALUES
;                                                               (UNSIGNED-BYTE
;                                                                64)
;                                                               &OPTIONAL).
;       etc.

;     (1+ (- IRONCLAD::I IRONCLAD::K))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER -7), not a FIXNUM.
;       The result is a (VALUES (INTEGER -6) &OPTIONAL), not a (VALUES FIXNUM
;                                                                      &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER -7), not a FIXNUM.
;       The result is a (VALUES (INTEGER -6) &OPTIONAL), not a (VALUES FIXNUM
;                                                                      &OPTIONAL).
;       etc.

;     (- IRONCLAD::I IRONCLAD::S)
; 
; 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 second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (1+ (- IRONCLAD::I IRONCLAD::S))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       etc.

;     (DOTIMES (IRONCLAD::H IRONCLAD::TMP)
;       (SETQ IRONCLAD::RES (MOD (* IRONCLAD::RES IRONCLAD::RES) IRONCLAD::M)))
; --> BLOCK LET TAGBODY UNLESS IF >= 
; ==>
;   1
; 
; 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 INTEGER, not a FIXNUM.

;     (* IRONCLAD::RES IRONCLAD::RES)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0))) (RATIONAL 0))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0))) (RATIONAL 0))
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (DOTIMES (IRONCLAD::H IRONCLAD::TMP)
;       (SETQ IRONCLAD::RES (MOD (* IRONCLAD::RES IRONCLAD::RES) IRONCLAD::M)))
; --> BLOCK LET TAGBODY PSETQ PROGN SETQ THE 1+ 
; ==>
;   1
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       etc.

;     (* IRONCLAD::RES (SVREF IRONCLAD::TAB (ASH IRONCLAD::U -1)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

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

; in: DEFUN MILLER-RABIN-DECOMPOSITION
;     (1+ IRONCLAD::K)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES (INTEGER 2) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       etc.

; in: DEFUN MILLER-RABIN-KERNEL
;     (= IRONCLAD::Y 1)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (= IRONCLAD::Y IRONCLAD::MINUS1)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

;     (= IRONCLAD::J IRONCLAD::K)
; 
; note: unable to open code because: The operands might not be the same type.

;     (= IRONCLAD::Y IRONCLAD::MINUS1)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

;     (= IRONCLAD::Y 1)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

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

;     (+ (IRONCLAD:STRONG-RANDOM (- IRONCLAD::N 2)) 2)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

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

;     (= IRONCLAD::Y IRONCLAD::MINUS1)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       etc.
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       etc.

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

; in: DEFUN LUCAS-SEQUENCE
;     (MOD (1- (* IRONCLAD::UH IRONCLAD::VL)) IRONCLAD::N)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a FIXNUM.

;     (MOD (- (* IRONCLAD::VH IRONCLAD::VL) IRONCLAD::P) IRONCLAD::N)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a FIXNUM.

;     (MOD (* IRONCLAD::UH IRONCLAD::VL) IRONCLAD::N)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a FIXNUM.

;     (MOD (- (* IRONCLAD::VL IRONCLAD::VL) 2) IRONCLAD::N)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (REAL -2), not a SINGLE-FLOAT.
;   The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (REAL -2), not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (REAL -2), not a INTEGER.
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (REAL -2), not a INTEGER.
;   The second argument is a REAL, not a FIXNUM.

;     (MOD (* IRONCLAD::UH IRONCLAD::VH) IRONCLAD::N)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a FIXNUM.

;     (MOD (- (* IRONCLAD::VH IRONCLAD::VL) IRONCLAD::P) IRONCLAD::N)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a FIXNUM.

;     (MOD (- (* IRONCLAD::VH IRONCLAD::VH) 2) IRONCLAD::N)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a FIXNUM.

;     (MOD (1- (* IRONCLAD::UH IRONCLAD::VL)) IRONCLAD::N)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a FIXNUM.

;     (MOD (- (* IRONCLAD::VH IRONCLAD::VL) IRONCLAD::P) IRONCLAD::N)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
;   The second argument is a REAL, not a FIXNUM.

;     (MOD (- (* IRONCLAD::VL IRONCLAD::VL) 2) IRONCLAD::N)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (REAL -2), not a SINGLE-FLOAT.
;   The second argument is a REAL, not a (OR SINGLE-FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (REAL -2), not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a (OR FLOAT INTEGER).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (REAL -2), not a INTEGER.
;   The second argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (REAL -2), not a INTEGER.
;   The second argument is a REAL, not a FIXNUM.

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

;     (INTEGER-LENGTH IRONCLAD::K)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (* IRONCLAD::UH IRONCLAD::VL)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

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

;     (* IRONCLAD::VH IRONCLAD::VL)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::VH IRONCLAD::VL) IRONCLAD::P)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                              &OPTIONAL).
;       etc.

;     (* IRONCLAD::VL IRONCLAD::VL)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0))) (RATIONAL 0))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0))) (RATIONAL 0))
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::VL IRONCLAD::VL) 2)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0)))
;                                   (RATIONAL 0)), not a FIXNUM.
;       The result is a (VALUES (REAL -2) &OPTIONAL), not a (VALUES FIXNUM
;                                                                   &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0)))
;                                   (RATIONAL 0)), not a FIXNUM.
;       The result is a (VALUES (REAL -2) &OPTIONAL), not a (VALUES FIXNUM
;                                                                   &OPTIONAL).
;       etc.

;     (* IRONCLAD::UH IRONCLAD::VH)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

;     (* IRONCLAD::VH IRONCLAD::VL)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::VH IRONCLAD::VL) IRONCLAD::P)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                              &OPTIONAL).
;       etc.

;     (* IRONCLAD::VH IRONCLAD::VH)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::VH IRONCLAD::VH) 2)
; 
; 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 REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* IRONCLAD::UH IRONCLAD::VL)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

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

;     (* IRONCLAD::VH IRONCLAD::VL)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::VH IRONCLAD::VL) IRONCLAD::P)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                              &OPTIONAL).
;       etc.

;     (DOTIMES (IRONCLAD::J IRONCLAD::S)
;       (SETQ IRONCLAD::UH (MOD (* IRONCLAD::UH IRONCLAD::VL) IRONCLAD::N))
;       (SETQ IRONCLAD::VL (MOD (- # 2) IRONCLAD::N)))
; --> BLOCK LET TAGBODY UNLESS IF >= 
; ==>
;   1
; 
; 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 UNSIGNED-BYTE, not a FIXNUM.

;     (* IRONCLAD::UH IRONCLAD::VL)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

;     (* IRONCLAD::VL IRONCLAD::VL)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES
;                        (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0))) (RATIONAL 0))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0))) (RATIONAL 0))
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::VL IRONCLAD::VL) 2)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0)))
;                                   (RATIONAL 0)), not a FIXNUM.
;       The result is a (VALUES (REAL -2) &OPTIONAL), not a (VALUES FIXNUM
;                                                                   &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (OR (MEMBER 0.0d0 0.0) (FLOAT (0.0)))
;                                   (RATIONAL 0)), not a FIXNUM.
;       The result is a (VALUES (REAL -2) &OPTIONAL), not a (VALUES FIXNUM
;                                                                   &OPTIONAL).
;       etc.

;     (DOTIMES (IRONCLAD::J IRONCLAD::S)
;       (SETQ IRONCLAD::UH (MOD (* IRONCLAD::UH IRONCLAD::VL) IRONCLAD::N))
;       (SETQ IRONCLAD::VL (MOD (- # 2) IRONCLAD::N)))
; --> BLOCK LET TAGBODY PSETQ PROGN SETQ THE 1+ 
; ==>
;   1
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       etc.

; in: DEFUN PRIMEP-LUCAS
;     (ZEROP (IRONCLAD::LUCAS-SEQUENCE (1+ IRONCLAD::N) IRONCLAD::B IRONCLAD::N))
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (* IRONCLAD::B IRONCLAD::B)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 3), not a FIXNUM.
;       The second argument is a (INTEGER 3), not a FIXNUM.
;       The result is a (VALUES (INTEGER 9) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 3), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER 3), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER 9) &OPTIONAL), not a (VALUES
;                                                              (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::B IRONCLAD::B) 4)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER 9), not a FIXNUM.
;       The result is a (VALUES (INTEGER 5) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 9), not a FIXNUM.
;       The result is a (VALUES (INTEGER 5) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       etc.

;     (INCF IRONCLAD::B)
; ==>
;   (+ 1 IRONCLAD::B)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER 3), not a FIXNUM.
;       The result is a (VALUES (INTEGER 4) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 3), not a FIXNUM.
;       The result is a (VALUES (INTEGER 4) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       etc.

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

; in: DEFUN MODULAR-INVERSE
;     (MOD IRONCLAD::INVERSE IRONCLAD::MODULUS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (INTEGER 1), not a FIXNUM.

;     (FLOOR IRONCLAD::R1 IRONCLAD::R2)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR (INTEGER * -1) (INTEGER 1)), not a FIXNUM.

;     (MOD (* IRONCLAD::N IRONCLAD::INVERSE) IRONCLAD::MODULUS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (INTEGER 1), not a FIXNUM.

;     (* IRONCLAD::Q IRONCLAD::U2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (DECF IRONCLAD::U1 (* IRONCLAD::Q IRONCLAD::U2))
; --> THE SB-IMPL::XSUBTRACT BLOCK 
; ==>
;   (- SB-IMPL::B SB-IMPL::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

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

;     (* IRONCLAD::N IRONCLAD::INVERSE)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

; in: DEFUN MODULAR-INVERSE-WITH-BLINDING
;     (GCD IRONCLAD::B IRONCLAD::MODULUS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a INTEGER, not a FIXNUM.
;   The second argument is a (INTEGER 1), not a FIXNUM.

;     (MOD (* IRONCLAD::N IRONCLAD::B) IRONCLAD::MODULUS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (INTEGER 1), not a FIXNUM.

;     (MOD (* IRONCLAD::Y IRONCLAD::B) IRONCLAD::MODULUS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (INTEGER 1), not a FIXNUM.

;     (- IRONCLAD::MODULUS 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       etc.

;     (+ 1 (IRONCLAD:STRONG-RANDOM (- IRONCLAD::MODULUS 1)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* IRONCLAD::N IRONCLAD::B)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y IRONCLAD::B)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

; in: DEFUN EXPT-MOD
;     (MOD (* IRONCLAD::R0 IRONCLAD::R1) IRONCLAD::MODULUS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (INTEGER 2), not a FIXNUM.

;     (MOD (* IRONCLAD::R1 IRONCLAD::R1) IRONCLAD::MODULUS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (INTEGER 2), not a FIXNUM.

;     (MOD (* IRONCLAD::R0 IRONCLAD::R1) IRONCLAD::MODULUS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (INTEGER 2), not a FIXNUM.

;     (MOD (* IRONCLAD::R0 IRONCLAD::R0) IRONCLAD::MODULUS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (INTEGER 2), not a FIXNUM.

;     (ASSERT (<= 0 IRONCLAD::EXPONENT IRONCLAD::MODULUS))
; --> LET WHEN IF <= 
; ==>
;   1
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
; 
; 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 INTEGER, not a FIXNUM.

;     (INTEGER-LENGTH IRONCLAD::MODULUS)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a (INTEGER 2), not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a (INTEGER 2), not a FIXNUM.
;       etc.

;     (* IRONCLAD::R0 IRONCLAD::R1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::R0 IRONCLAD::R0)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

;     (* IRONCLAD::R0 IRONCLAD::R1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::R1 IRONCLAD::R1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

; in: DEFUN PRIME-P
;     (LOOP IRONCLAD::REPEAT IRONCLAD:*NUMBER-OF-MILLER-RABIN-TESTS*
;           IRONCLAD::ALWAYS (IRONCLAD::MILLER-RABIN-KERNEL IRONCLAD::N IRONCLAD::Q
;                             IRONCLAD::K))
; --> LET CEILING 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (<= IRONCLAD::N IRONCLAD::+LAST-SMALL-PRIME+)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (LOOP IRONCLAD::REPEAT IRONCLAD:*NUMBER-OF-MILLER-RABIN-TESTS*
;           IRONCLAD::ALWAYS (IRONCLAD::MILLER-RABIN-KERNEL IRONCLAD::N IRONCLAD::Q
;                             IRONCLAD::K))
; --> LET TAGBODY IF <= 
; ==>
;   1
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> LET TAGBODY IF DECF SETQ THE SB-IMPL::XSUBTRACT BLOCK 
; ==>
;   (- SB-IMPL::B SB-IMPL::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/math-tmpCDM7YXYI.fasl
; compilation finished in 0:00:00.113
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/octet-stream.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/octet-stream-tmpLM57P5P.fasl
; compilation finished in 0:00:00.208
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/aead/aead.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/aead/aead-tmpZE69DN33.fasl
; compilation finished in 0:00:00.015
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/kdf/kdf.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/kdf/kdf-tmpG8099TO3.fasl
; compilation finished in 0:00:00.028
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/public-key.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/public-key/public-key.lisp
; in: DEFUN OCTETS-TO-INTEGER
;     (CEILING IRONCLAD::N-BITS 8)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (MIN (CEILING IRONCLAD::N-BITS 8) IRONCLAD::SIZE)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (* 8 IRONCLAD::SIZE)
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.

;     (LOOP IRONCLAD::WITH
;           IRONCLAD::SUM = 0
;           IRONCLAD::FOR IRONCLAD::I IRONCLAD::FROM (- IRONCLAD::END
;                                                       IRONCLAD::N-BYTES) IRONCLAD::BELOW
;           IRONCLAD::END
;           DO ...)
; --> LET LET TAGBODY WHEN IF 
; ==>
;   (>= IRONCLAD::I #:LIM0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (LOOP IRONCLAD::FOR IRONCLAD::I IRONCLAD::FROM IRONCLAD::START IRONCLAD::BELOW (+
;                                                                                     IRONCLAD::START
;                                                                                     IRONCLAD::N-BYTES)
;           IRONCLAD::FOR IRONCLAD::J IRONCLAD::FROM 0 IRONCLAD::BY ...)
; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY WHEN IF 
; ==>
;   (>= IRONCLAD::I #:LIM1)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (LDB (BYTE IRONCLAD::N-BITS 0) IRONCLAD::SUM)
; 
; note: unable to
;   convert to inline logical operations
; due to type uncertainty:
;   The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                            (UNSIGNED-BYTE 64)
;                                                            &REST T).

;     (- IRONCLAD::END IRONCLAD::START)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (NOT NULL), not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.

;     (* 8 IRONCLAD::SIZE)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (MIN (CEILING IRONCLAD::N-BITS 8) IRONCLAD::SIZE)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.

;     (+ IRONCLAD::START IRONCLAD::N-BYTES)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.

;     (LOOP IRONCLAD::FOR IRONCLAD::I IRONCLAD::FROM IRONCLAD::START IRONCLAD::BELOW (+
;                                                                                     IRONCLAD::START
;                                                                                     IRONCLAD::N-BYTES)
;           IRONCLAD::FOR IRONCLAD::J IRONCLAD::FROM 0 IRONCLAD::BY ...)
; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY WHEN IF 
; ==>
;   (>= IRONCLAD::I #:LIM1)
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.

;     (ASH (AREF IRONCLAD::OCTET-VEC IRONCLAD::I) IRONCLAD::J)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a (OR (INTEGER 0 0) (INTEGER 8 8) (INTEGER 16 16)
;                                    (INTEGER 24 24) (INTEGER 32 32)
;                                    (INTEGER 40 40) (INTEGER 48)), not a (UNSIGNED-BYTE
;                                                                          64).
;       The result is a (VALUES
;                        (OR (MOD 65281) (INTEGER 65536 16711680)
;                            (INTEGER 16777216 4278190080)
;                            (INTEGER 4294967296 1095216660480)
;                            (INTEGER 1099511627776 280375465082880)
;                            (INTEGER 281474976710656))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 4) because:
;       The second argument is a (OR (INTEGER 0 0) (INTEGER 8 8) (INTEGER 16 16)
;                                    (INTEGER 24 24) (INTEGER 32 32)
;                                    (INTEGER 40 40) (INTEGER 48)), not a (UNSIGNED-BYTE
;                                                                          62).
;       The result is a (VALUES
;                        (OR (MOD 65281) (INTEGER 65536 16711680)
;                            (INTEGER 16777216 4278190080)
;                            (INTEGER 4294967296 1095216660480)
;                            (INTEGER 1099511627776 280375465082880)
;                            (INTEGER 281474976710656))
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (LOOP IRONCLAD::FOR IRONCLAD::I IRONCLAD::FROM IRONCLAD::START IRONCLAD::BELOW (+
;                                                                                     IRONCLAD::START
;                                                                                     IRONCLAD::N-BYTES)
;           IRONCLAD::FOR IRONCLAD::J IRONCLAD::FROM 0 IRONCLAD::BY ...)
; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:SUM2 (ASH (AREF IRONCLAD::OCTET-VEC IRONCLAD::I) IRONCLAD::J))
; 
; 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 second argument is a (OR (MOD 65281) (INTEGER 65536 16711680)
;                                    (INTEGER 16777216 4278190080)
;                                    (INTEGER 4294967296 1095216660480)
;                                    (INTEGER 1099511627776 280375465082880)
;                                    (INTEGER 281474976710656)), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a (OR (MOD 65281) (INTEGER 65536 16711680)
;                                    (INTEGER 16777216 4278190080)
;                                    (INTEGER 4294967296 1095216660480)
;                                    (INTEGER 1099511627776 280375465082880)
;                                    (INTEGER 281474976710656)), not a (UNSIGNED-BYTE
;                                                                       64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 
; ==>
;   (+ IRONCLAD::J 8)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (OR (INTEGER 0 0) (INTEGER 8 8) (INTEGER 16 16)
;                                   (INTEGER 24 24) (INTEGER 32 32)
;                                   (INTEGER 40 40) (INTEGER 48)), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 8 8) (INTEGER 16 16) (INTEGER 24 24)
;                            (INTEGER 32 32) (INTEGER 40 40) (INTEGER 48))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (INTEGER 0 0) (INTEGER 8 8) (INTEGER 16 16)
;                                   (INTEGER 24 24) (INTEGER 32 32)
;                                   (INTEGER 40 40) (INTEGER 48)), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 8 8) (INTEGER 16 16) (INTEGER 24 24)
;                            (INTEGER 32 32) (INTEGER 40 40) (INTEGER 48))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- IRONCLAD::END IRONCLAD::N-BYTES)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.

;     (LOOP IRONCLAD::WITH
;           IRONCLAD::SUM = 0
;           IRONCLAD::FOR IRONCLAD::I IRONCLAD::FROM (- IRONCLAD::END
;                                                       IRONCLAD::N-BYTES) IRONCLAD::BELOW
;           IRONCLAD::END
;           DO ...)
; --> LET LET TAGBODY WHEN IF 
; ==>
;   (>= IRONCLAD::I #:LIM0)
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.

; in: DEFUN INTEGER-TO-OCTETS
;     (LDB (BYTE IRONCLAD::N-BITS 0) BIGNUM)
; 
; note: unable to
;   convert to inline logical operations
; due to type uncertainty:
;   The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                            (UNSIGNED-BYTE 64)
;                                                            &REST T).

;     (INTEGER-LENGTH BIGNUM)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a T, not a FIXNUM.
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/public-key-tmpTASQCYAW.fasl
; compilation finished in 0:00:00.060
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/pkcs1.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/pkcs1-tmp35U57IV6.fasl
; compilation finished in 0:00:00.050
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/elliptic-curve.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/elliptic-curve-tmpTZOONXRW.fasl
; compilation finished in 0:00:00.003
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/aes.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/aes-tmpWN0UKDSV.fasl
; compilation finished in 0:00:00.405
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/arcfour.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/arcfour-tmpBF3HHBTQ.fasl
; compilation finished in 0:00:00.077
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/aria.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/aria-tmpGYUNPZCY.fasl
; compilation finished in 0:00:00.256
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/blowfish.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/blowfish-tmpD68Q8WCA.fasl
; compilation finished in 0:00:00.589
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/camellia.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/camellia-tmp7MK9KM9C.fasl
; compilation finished in 0:00:00.303
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/cast5.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/cast5-tmpJJ71X849.fasl
; compilation finished in 0:00:00.721
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/chacha.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/chacha-tmp1VUK6SR2.fasl
; compilation finished in 0:00:00.114
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/xchacha.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/xchacha-tmpR2FIHSUG.fasl
; compilation finished in 0:00:00.071
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/des.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/des-tmp8PYELRKX.fasl
; compilation finished in 0:00:00.288
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/idea.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/idea-tmpEHTOKYT0.fasl
; compilation finished in 0:00:00.171
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/kalyna.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/kalyna-tmpS6U1VHI9.fasl
; compilation finished in 0:00:13.424
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/salsa20.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/salsa20-tmpVTFK6ZJW.fasl
; compilation finished in 0:00:00.057
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/keystream.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/keystream-tmp75WVSJEW.fasl
; compilation finished in 0:00:00.011
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/kuznyechik.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/kuznyechik-tmpBU5UM3S4.fasl
; compilation finished in 0:00:04.882
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/misty1.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/misty1-tmpOBHVA3CD.fasl
; compilation finished in 0:00:00.173
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/rc2.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/rc2-tmpJ6ELVFLF.fasl
; compilation finished in 0:00:00.261
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/rc5.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/rc5-tmpULDB0RG.fasl
; compilation finished in 0:00:00.214
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/rc6.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/rc6-tmpUTZ0UUTE.fasl
; compilation finished in 0:00:00.240
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/xsalsa20.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/xsalsa20-tmpOOSRA8PZ.fasl
; compilation finished in 0:00:00.054
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/seed.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/seed-tmpDMIL0RVK.fasl
; compilation finished in 0:00:00.468
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/serpent.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/serpent-tmp8MR9IMIO.fasl
; compilation finished in 0:00:01.499
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/sm4.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/sm4-tmpJQDKAVAY.fasl
; compilation finished in 0:00:00.302
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/sosemanuk.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/sosemanuk-tmp3I8CEEQY.fasl
; compilation finished in 0:00:01.916
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/square.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/square.lisp
; in: DEFINE-BLOCK-ENCRYPTOR SQUARE
;     (IRONCLAD::SQUARE-MUNGE-BLOCK IRONCLAD::ROUND-KEYS IRONCLAD::N-ROUNDS
;      IRONCLAD::T-ENCRYPTION-TABLE IRONCLAD::S-ENCRYPTION-TABLE
;      IRONCLAD::PLAINTEXT IRONCLAD::PLAINTEXT-START IRONCLAD::CIPHERTEXT
;      IRONCLAD::CIPHERTEXT-START)
; --> BLOCK IRONCLAD::WITH-WORDS MACROLET LET MACROLET LET FLET 
; --> IRONCLAD::STORE-WORDS PROGN SETF SB-C::WITH-SOURCE-FORM 
; --> IRONCLAD:UB32REF/BE LET* IRONCLAD::APPLY-RK IRONCLAD::RKREF AREF + 
; ==>
;   (* IRONCLAD::N-ROUNDS 4)
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a (RATIONAL -1152921504606846976
;                                     4611686018427387903/4), not a INTEGER.
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a (RATIONAL -1152921504606846976
;                                     2305843009213693951/2), not a INTEGER.
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a (RATIONAL -1152921504606846976
;                                     4611686018427387901/4), not a INTEGER.

; --> BLOCK IRONCLAD::WITH-WORDS MACROLET LET LET DO BLOCK LET TAGBODY UNLESS 
; --> IF >= 1- 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

; --> BLOCK IRONCLAD::WITH-WORDS MACROLET LET MACROLET LET FLET 
; --> IRONCLAD::STORE-WORDS PROGN SETF SB-C::WITH-SOURCE-FORM 
; --> IRONCLAD:UB32REF/BE LET* IRONCLAD::APPLY-RK IRONCLAD::RKREF AREF + 
; ==>
;   (* IRONCLAD::N-ROUNDS 4)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (RATIONAL -1152921504606846976
;                                         4611686018427387903/4), not a FIXNUM.
;       The result is a (VALUES
;                        (RATIONAL -4611686018427387904 4611686018427387903)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL -1152921504606846976
;                                         4611686018427387903/4), not a FIXNUM.
;       The result is a (VALUES
;                        (RATIONAL -4611686018427387904 4611686018427387903)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (RATIONAL -1152921504606846976
;                                         2305843009213693951/2), not a FIXNUM.
;       The result is a (VALUES
;                        (RATIONAL -4611686018427387904 4611686018427387902)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL -1152921504606846976
;                                         2305843009213693951/2), not a FIXNUM.
;       The result is a (VALUES
;                        (RATIONAL -4611686018427387904 4611686018427387902)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (RATIONAL -1152921504606846976
;                                         4611686018427387901/4), not a FIXNUM.
;       The result is a (VALUES
;                        (RATIONAL -4611686018427387904 4611686018427387901)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL -1152921504606846976
;                                         4611686018427387901/4), not a FIXNUM.
;       The result is a (VALUES
;                        (RATIONAL -4611686018427387904 4611686018427387901)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

; --> BLOCK IRONCLAD::WITH-WORDS MACROLET LET LET DO BLOCK LET TAGBODY PSETQ 
; --> LET* 1+ 
; ==>
;   1
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       etc.

; in: DEFINE-BLOCK-DECRYPTOR SQUARE
;     (IRONCLAD::SQUARE-MUNGE-BLOCK IRONCLAD::ROUND-KEYS IRONCLAD::N-ROUNDS
;      IRONCLAD::T-DECRYPTION-TABLE IRONCLAD::S-DECRYPTION-TABLE
;      IRONCLAD::CIPHERTEXT IRONCLAD::CIPHERTEXT-START IRONCLAD::PLAINTEXT
;      IRONCLAD::PLAINTEXT-START)
; --> BLOCK IRONCLAD::WITH-WORDS MACROLET LET MACROLET LET FLET 
; --> IRONCLAD::STORE-WORDS PROGN SETF SB-C::WITH-SOURCE-FORM 
; --> IRONCLAD:UB32REF/BE LET* IRONCLAD::APPLY-RK IRONCLAD::RKREF AREF + 
; ==>
;   (* IRONCLAD::N-ROUNDS 4)
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a (RATIONAL -1152921504606846976
;                                     4611686018427387903/4), not a INTEGER.
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a (RATIONAL -1152921504606846976
;                                     2305843009213693951/2), not a INTEGER.
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a (RATIONAL -1152921504606846976
;                                     4611686018427387901/4), not a INTEGER.

; --> BLOCK IRONCLAD::WITH-WORDS MACROLET LET LET DO BLOCK LET TAGBODY UNLESS 
; --> IF >= 1- 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

; --> BLOCK IRONCLAD::WITH-WORDS MACROLET LET MACROLET LET FLET 
; --> IRONCLAD::STORE-WORDS PROGN SETF SB-C::WITH-SOURCE-FORM 
; --> IRONCLAD:UB32REF/BE LET* IRONCLAD::APPLY-RK IRONCLAD::RKREF AREF + 
; ==>
;   (* IRONCLAD::N-ROUNDS 4)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (RATIONAL -1152921504606846976
;                                         4611686018427387903/4), not a FIXNUM.
;       The result is a (VALUES
;                        (RATIONAL -4611686018427387904 4611686018427387903)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL -1152921504606846976
;                                         4611686018427387903/4), not a FIXNUM.
;       The result is a (VALUES
;                        (RATIONAL -4611686018427387904 4611686018427387903)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (RATIONAL -1152921504606846976
;                                         2305843009213693951/2), not a FIXNUM.
;       The result is a (VALUES
;                        (RATIONAL -4611686018427387904 4611686018427387902)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL -1152921504606846976
;                                         2305843009213693951/2), not a FIXNUM.
;       The result is a (VALUES
;                        (RATIONAL -4611686018427387904 4611686018427387902)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (RATIONAL -1152921504606846976
;                                         4611686018427387901/4), not a FIXNUM.
;       The result is a (VALUES
;                        (RATIONAL -4611686018427387904 4611686018427387901)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL -1152921504606846976
;                                         4611686018427387901/4), not a FIXNUM.
;       The result is a (VALUES
;                        (RATIONAL -4611686018427387904 4611686018427387901)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

; --> BLOCK IRONCLAD::WITH-WORDS MACROLET LET LET DO BLOCK LET TAGBODY PSETQ 
; --> LET* 1+ 
; ==>
;   1
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/square-tmpA3RHFLWZ.fasl
; compilation finished in 0:00:00.475
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/tea.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/tea-tmpYZIB7VXO.fasl
; compilation finished in 0:00:00.245
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/threefish.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/threefish-tmpR8PK79V8.fasl
; compilation finished in 0:00:06.954
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/twofish.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/twofish-tmpN1ZVB1HZ.fasl
; compilation finished in 0:00:00.516
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/xor.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/xor-tmpZGRRPISB.fasl
; compilation finished in 0:00:00.021
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/xtea.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/ciphers/xtea-tmpFNKDE5XP.fasl
; compilation finished in 0:00:00.037
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/adler32.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/adler32.lisp
; in: DEFINE-DIGEST-FINALIZER (ADLER32 4)
;     (ASH (IRONCLAD::ADLER32-S2 IRONCLAD::STATE) 16)
; 
; note: forced to do */SIGNED=>INTEGER (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The result is a (VALUES
;                        (OR (INTEGER -302231454903657293676544 -65536)
;                            (INTEGER 0 0)
;                            (INTEGER 65536 302231454903657293611008))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The result is a (VALUES
;                        (OR (INTEGER -302231454903657293676544 -65536)
;                            (INTEGER 0 0)
;                            (INTEGER 65536 302231454903657293611008))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (LOGIOR (ASH (IRONCLAD::ADLER32-S2 IRONCLAD::STATE) 16)
;             (IRONCLAD::ADLER32-S1 IRONCLAD::STATE))
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (INTEGER -302231454903657293676544 -65536)
;                                   (INTEGER 0 0)
;                                   (INTEGER 65536 302231454903657293611008)), not a FIXNUM.
;       The result is a (VALUES (SIGNED-BYTE 79) &OPTIONAL), not a (VALUES FIXNUM
;                                                                          &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a (OR (INTEGER -302231454903657293676544 -65536)
;                                   (INTEGER 0 0)
;                                   (INTEGER 65536 302231454903657293611008)), not a (UNSIGNED-BYTE
;                                                                                     64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (SIGNED-BYTE 79) &OPTIONAL), not a (VALUES
;                                                                   (UNSIGNED-BYTE
;                                                                    64)
;                                                                   &OPTIONAL).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/adler32-tmpRJTU435C.fasl
; compilation finished in 0:00:00.045
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/blake2.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/blake2.lisp
; in: DEFUN BLAKE2-ROUNDS
;     (LDB (BYTE 64 0) IRONCLAD::OFFSET)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline (unsigned-byte 64) arithmetic (cost 2) because:
;       The first argument is a (UNSIGNED-BYTE 128), not a (UNSIGNED-BYTE 64).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 2) because:
;       The first argument is a (UNSIGNED-BYTE 128), not a (SIGNED-BYTE 64).
;       etc.

; in: DEFUN BLAKE2-UPDATE
;     (INCF IRONCLAD::OFFSET IRONCLAD::N)
; --> THE 
; ==>
;   (+ IRONCLAD::N IRONCLAD::OFFSET)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (UNSIGNED-BYTE 128), not a FIXNUM.
;       The result is a (VALUES (UNSIGNED-BYTE 128) &OPTIONAL), not a (VALUES
;                                                                      FIXNUM
;                                                                      &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER -4611686018427387903 128), not a (UNSIGNED-BYTE
;                                                                          64).
;       The second argument is a (UNSIGNED-BYTE 128), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (UNSIGNED-BYTE 128) &OPTIONAL), not a (VALUES
;                                                                      (UNSIGNED-BYTE
;                                                                       64)
;                                                                      &OPTIONAL).
;       etc.

;     (INCF IRONCLAD::OFFSET IRONCLAD::+BLAKE2-BLOCK-SIZE+)
; --> THE 
; ==>
;   (+ IRONCLAD::+BLAKE2-BLOCK-SIZE+ IRONCLAD::OFFSET)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (UNSIGNED-BYTE 128), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER 128 340282366920938463463374607431768211455)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (UNSIGNED-BYTE 128), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER 128 340282366920938463463374607431768211455)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (INCF IRONCLAD::OFFSET LENGTH)
; --> THE 
; ==>
;   (+ LENGTH IRONCLAD::OFFSET)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (UNSIGNED-BYTE 128), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER 1 340282366920938463463374607431768211455)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (UNSIGNED-BYTE 128), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER 1 340282366920938463463374607431768211455)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/blake2-tmpI9WG87JK.fasl
; compilation finished in 0:00:00.870
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/blake2s.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/blake2s.lisp
; in: DEFUN BLAKE2S-UPDATE
;     (IRONCLAD::BLAKE2S-ROUNDS IRONCLAD::BLAKE2S-STATE IRONCLAD::INPUT
;      IRONCLAD::START IRONCLAD::OFFSET NIL)
; 
; note: doing unsigned word to integer coercion (cost 20) from OFFSET

;     (IRONCLAD::BLAKE2S-ROUNDS IRONCLAD::BLAKE2S-STATE IRONCLAD::BUFFER 0
;      IRONCLAD::OFFSET IRONCLAD::FINAL)
; 
; note: doing unsigned word to integer coercion (cost 20) from OFFSET


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/blake2s-tmpYDE6I9E6.fasl
; compilation finished in 0:00:00.561
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/crc24.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/crc24-tmp319UV2V8.fasl
; compilation finished in 0:00:00.033
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/crc32.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/crc32-tmpLYQINFYS.fasl
; compilation finished in 0:00:00.030
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/groestl.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/groestl.lisp
; in: DEFUN GROESTL-UPDATE
;     (INCF IRONCLAD::BLOCK-COUNTER)
; ==>
;   (+ 1 IRONCLAD::BLOCK-COUNTER)
; 
; note: forced to do +/UNSIGNED=>INTEGER (cost 8)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (UNSIGNED-BYTE 64), not a FIXNUM.
;       The result is a (VALUES (INTEGER 1 18446744073709551616) &OPTIONAL), not a (VALUES
;                                                                                   FIXNUM
;                                                                                   &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (UNSIGNED-BYTE 64), not a FIXNUM.
;       The result is a (VALUES (INTEGER 1 18446744073709551616) &OPTIONAL), not a (VALUES
;                                                                                   FIXNUM
;                                                                                   &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                     &OPTIONAL).
;       etc.

;     (LET* ((IRONCLAD::GROESTL-STATE (IRONCLAD::GROESTL-STATE IRONCLAD::STATE))
;            (IRONCLAD::BUFFER (IRONCLAD::GROESTL-BUFFER IRONCLAD::STATE))
;            (IRONCLAD::BUFFER-INDEX
;             (IRONCLAD::GROESTL-BUFFER-INDEX IRONCLAD::STATE))
;            (IRONCLAD::BLOCK-COUNTER
;             (IRONCLAD::GROESTL-BLOCK-COUNTER IRONCLAD::STATE))
;            (IRONCLAD::BLOCK-SIZE (LENGTH IRONCLAD::BUFFER))
;            (IRONCLAD::TRANSFORM
;             (IF (= IRONCLAD::BLOCK-SIZE IRONCLAD::+GROESTL-SIZE-512+)
;                 #'IRONCLAD::GROESTL-F512
;                 #'IRONCLAD::GROESTL-F1024))
;            (LENGTH (- IRONCLAD::END IRONCLAD::START))
;            (IRONCLAD::N 0))
;       (DECLARE
;        (TYPE (SIMPLE-ARRAY (UNSIGNED-BYTE 64) (*)) IRONCLAD::GROESTL-STATE)
;        (TYPE (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)) IRONCLAD::BUFFER)
;        (TYPE (INTEGER 0 128) IRONCLAD::BLOCK-SIZE IRONCLAD::BUFFER-INDEX
;         IRONCLAD::N)
;        (TYPE (UNSIGNED-BYTE 64) LENGTH))
;       (SETF IRONCLAD::N
;               (MIN LENGTH (- IRONCLAD::BLOCK-SIZE IRONCLAD::BUFFER-INDEX)))
;       (REPLACE IRONCLAD::BUFFER IRONCLAD::INPUT :START1 IRONCLAD::BUFFER-INDEX
;                :START2 IRONCLAD::START :END2 (+ IRONCLAD::START IRONCLAD::N))
;       (INCF IRONCLAD::BUFFER-INDEX IRONCLAD::N)
;       (INCF IRONCLAD::START IRONCLAD::N)
;       (DECF LENGTH IRONCLAD::N)
;       (WHEN (= IRONCLAD::BUFFER-INDEX IRONCLAD::BLOCK-SIZE)
;         (FUNCALL IRONCLAD::TRANSFORM IRONCLAD::GROESTL-STATE IRONCLAD::BUFFER 0)
;         (SETF IRONCLAD::BUFFER-INDEX 0)
;         (INCF IRONCLAD::BLOCK-COUNTER))
;       (LOOP IRONCLAD::UNTIL (< LENGTH IRONCLAD::BLOCK-SIZE)
;             DO (FUNCALL IRONCLAD::TRANSFORM IRONCLAD::GROESTL-STATE
;                         IRONCLAD::INPUT IRONCLAD::START) (INCF
;                                                           IRONCLAD::BLOCK-COUNTER) (INCF
;                                                                                     IRONCLAD::START
;                                                                                     IRONCLAD::BLOCK-SIZE) (DECF
;                                                                                                            LENGTH
;                                                                                                            IRONCLAD::BLOCK-SIZE))
;       (WHEN (PLUSP LENGTH)
;         (REPLACE IRONCLAD::BUFFER IRONCLAD::INPUT :END1 LENGTH :START2
;                  IRONCLAD::START)
;         (SETF IRONCLAD::BUFFER-INDEX LENGTH))
;       (SETF (IRONCLAD::GROESTL-BLOCK-COUNTER IRONCLAD::STATE)
;               IRONCLAD::BLOCK-COUNTER
;             (IRONCLAD::GROESTL-BUFFER-INDEX IRONCLAD::STATE)
;               IRONCLAD::BUFFER-INDEX)
;       ...)
; 
; note: doing unsigned word to integer coercion (cost 20) to BLOCK-COUNTER

;     (FUNCALL IRONCLAD::TRANSFORM IRONCLAD::GROESTL-STATE IRONCLAD::INPUT
;              IRONCLAD::START)
; 
; note: doing unsigned word to integer coercion (cost 20) from START

; in: DEFUN GROESTL-FINALIZE
;     (REPLACE IRONCLAD::DIGEST IRONCLAD::OUTPUT :START1 IRONCLAD::DIGEST-START
;              :START2 (- IRONCLAD::BLOCK-SIZE IRONCLAD:DIGEST-LENGTH))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (OR NULL (SIMPLE-ARRAY * (*))).

;     (INCF IRONCLAD::BLOCK-COUNTER)
; ==>
;   (+ 1 IRONCLAD::BLOCK-COUNTER)
; 
; note: forced to do +/UNSIGNED=>INTEGER (cost 8)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (UNSIGNED-BYTE 64), not a FIXNUM.
;       The result is a (VALUES (INTEGER 1 18446744073709551616) &OPTIONAL), not a (VALUES
;                                                                                   FIXNUM
;                                                                                   &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (UNSIGNED-BYTE 64), not a FIXNUM.
;       The result is a (VALUES (INTEGER 1 18446744073709551616) &OPTIONAL), not a (VALUES
;                                                                                   FIXNUM
;                                                                                   &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (MOD 18446744073709551617), not a FIXNUM.
;       The result is a (VALUES (INTEGER 1 18446744073709551617) &OPTIONAL), not a (VALUES
;                                                                                   FIXNUM
;                                                                                   &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD 18446744073709551617), not a FIXNUM.
;       The result is a (VALUES (INTEGER 1 18446744073709551617) &OPTIONAL), not a (VALUES
;                                                                                   FIXNUM
;                                                                                   &OPTIONAL).
;       etc.

;     (- IRONCLAD::BLOCK-SIZE IRONCLAD:DIGEST-LENGTH)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a NUMBER, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       etc.

;     (LET* ((IRONCLAD:DIGEST-LENGTH (IRONCLAD:DIGEST-LENGTH IRONCLAD::STATE))
;            (IRONCLAD::GROESTL-STATE (IRONCLAD::GROESTL-STATE IRONCLAD::STATE))
;            (IRONCLAD::BUFFER (IRONCLAD::GROESTL-BUFFER IRONCLAD::STATE))
;            (IRONCLAD::BUFFER-INDEX
;             (IRONCLAD::GROESTL-BUFFER-INDEX IRONCLAD::STATE))
;            (IRONCLAD::BLOCK-COUNTER
;             (IRONCLAD::GROESTL-BLOCK-COUNTER IRONCLAD::STATE))
;            (IRONCLAD::BLOCK-SIZE (LENGTH IRONCLAD::BUFFER))
;            (IRONCLAD::TRANSFORM
;             (IF (= IRONCLAD::BLOCK-SIZE IRONCLAD::+GROESTL-SIZE-512+)
;                 #'IRONCLAD::GROESTL-F512
;                 #'IRONCLAD::GROESTL-F1024)))
;       (DECLARE
;        (TYPE (SIMPLE-ARRAY (UNSIGNED-BYTE 64) (*)) IRONCLAD::GROESTL-STATE)
;        (TYPE (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)) IRONCLAD::BUFFER)
;        (TYPE (INTEGER 0 128) IRONCLAD::BLOCK-SIZE IRONCLAD::BUFFER-INDEX)
;        (OPTIMIZE (SPEED 3) (SPACE 0) (SAFETY 0) (DEBUG 0)))
;       (SETF (AREF IRONCLAD::BUFFER IRONCLAD::BUFFER-INDEX) 128)
;       (INCF IRONCLAD::BUFFER-INDEX)
;       (WHEN
;           (> IRONCLAD::BUFFER-INDEX
;              (- IRONCLAD::BLOCK-SIZE IRONCLAD::+GROESTL-LENGTH-FIELD-LENGTH+))
;         (FILL IRONCLAD::BUFFER 0 :START IRONCLAD::BUFFER-INDEX)
;         (FUNCALL IRONCLAD::TRANSFORM IRONCLAD::GROESTL-STATE IRONCLAD::BUFFER 0)
;         (INCF IRONCLAD::BLOCK-COUNTER)
;         (SETF IRONCLAD::BUFFER-INDEX 0))
;       (FILL IRONCLAD::BUFFER 0 :START IRONCLAD::BUFFER-INDEX)
;       (SETF IRONCLAD::BUFFER-INDEX
;               (- IRONCLAD::BLOCK-SIZE IRONCLAD::+GROESTL-LENGTH-FIELD-LENGTH+))
;       (INCF IRONCLAD::BLOCK-COUNTER)
;       (SETF (IRONCLAD:UB64REF/BE IRONCLAD::BUFFER IRONCLAD::BUFFER-INDEX)
;               IRONCLAD::BLOCK-COUNTER)
;       (FUNCALL IRONCLAD::TRANSFORM IRONCLAD::GROESTL-STATE IRONCLAD::BUFFER 0)
;       (IF (= IRONCLAD::BLOCK-SIZE IRONCLAD::+GROESTL-SIZE-512+)
;           (LET ((IRONCLAD::TEMP #) (IRONCLAD::Y #) (IRONCLAD::Z #))
;             (DECLARE (TYPE # IRONCLAD::TEMP IRONCLAD::Y IRONCLAD::Z)
;                      (DYNAMIC-EXTENT IRONCLAD::TEMP IRONCLAD::Y IRONCLAD::Z))
;             (IRONCLAD::GROESTL-RND512P IRONCLAD::TEMP IRONCLAD::Z 0)
;             (LOOP IRONCLAD::FOR IRONCLAD::I IRONCLAD::FROM 1 IRONCLAD::BELOW (1-
;                                                                               IRONCLAD::+GROESTL-ROUNDS-512+) IRONCLAD::BY 2
;                   DO (IRONCLAD::GROESTL-RND512P IRONCLAD::Z IRONCLAD::Y
;                       #) (IRONCLAD::GROESTL-RND512P IRONCLAD::Y IRONCLAD::Z #))
;             (IRONCLAD::GROESTL-RND512P IRONCLAD::Z IRONCLAD::TEMP (ASH # 56))
;             (DOTIMES (IRONCLAD::I IRONCLAD::+GROESTL-COLS-512+) (SETF #)))
;           (LET ((IRONCLAD::TEMP #) (IRONCLAD::Y #) (IRONCLAD::Z #))
;             (DECLARE (TYPE # IRONCLAD::TEMP IRONCLAD::Y IRONCLAD::Z)
;                      (DYNAMIC-EXTENT IRONCLAD::TEMP IRONCLAD::Y IRONCLAD::Z))
;             (IRONCLAD::GROESTL-RND1024P IRONCLAD::TEMP IRONCLAD::Y 0)
;             (LOOP IRONCLAD::FOR IRONCLAD::I IRONCLAD::FROM 1 IRONCLAD::BELOW (1-
;                                                                               IRONCLAD::+GROESTL-ROUNDS-1024+) IRONCLAD::BY 2
;                   DO (IRONCLAD::GROESTL-RND1024P IRONCLAD::Y IRONCLAD::Z
;                       #) (IRONCLAD::GROESTL-RND1024P IRONCLAD::Z IRONCLAD::Y #))
;             (IRONCLAD::GROESTL-RND1024P IRONCLAD::Y IRONCLAD::TEMP (ASH # 56))
;             (DOTIMES (IRONCLAD::I IRONCLAD::+GROESTL-COLS-1024+) (SETF #))))
;       ...)
; 
; note: doing unsigned word to integer coercion (cost 20) to BLOCK-COUNTER


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/groestl-tmpGA31XWNO.fasl
; compilation finished in 0:00:02.870
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/jh.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/jh-tmp5HT23M6C.fasl
; compilation finished in 0:00:00.759
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/kupyna.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/kupyna.lisp
; in: DEFINE-DIGEST-FINALIZER ((KUPYNA 64) (KUPYNA/256 32))
;     (INCF IRONCLAD::TOTAL (* 8 IRONCLAD::BUFFER-INDEX))
; ==>
;   (+ (* 8 IRONCLAD::BUFFER-INDEX) IRONCLAD::TOTAL)
; 
; note: forced to do +/UNSIGNED=>INTEGER (cost 8)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (UNSIGNED-BYTE 64), not a FIXNUM.
;       The result is a (VALUES (MOD 18446744073709552640) &OPTIONAL), not a (VALUES
;                                                                             FIXNUM
;                                                                             &OPTIONAL).

;     (> (+ IRONCLAD::BUFFER-INDEX 12) IRONCLAD:BLOCK-LENGTH)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a T, not a FIXNUM.

;     (LET ((IRONCLAD:BLOCK-LENGTH (IRONCLAD:BLOCK-LENGTH IRONCLAD::STATE))
;           (IRONCLAD:DIGEST-LENGTH (IRONCLAD:DIGEST-LENGTH IRONCLAD::STATE))
;           (IRONCLAD::BUFFER (IRONCLAD::KUPYNA-BUFFER IRONCLAD::STATE))
;           (IRONCLAD::BUFFER-INDEX
;            (IRONCLAD::KUPYNA-BUFFER-INDEX IRONCLAD::STATE))
;           (IRONCLAD::H (IRONCLAD::KUPYNA-H IRONCLAD::STATE))
;           (IRONCLAD::TOTAL (IRONCLAD::KUPYNA-TOTAL IRONCLAD::STATE)))
;       (INCF IRONCLAD::TOTAL (* 8 IRONCLAD::BUFFER-INDEX))
;       (SETF (AREF IRONCLAD::BUFFER IRONCLAD::BUFFER-INDEX) 128)
;       (INCF IRONCLAD::BUFFER-INDEX)
;       (WHEN (> (+ IRONCLAD::BUFFER-INDEX 12) IRONCLAD:BLOCK-LENGTH)
;         (FILL IRONCLAD::BUFFER 0 :START IRONCLAD::BUFFER-INDEX)
;         (ECASE IRONCLAD:BLOCK-LENGTH
;           (64 (IRONCLAD::KUPYNA-TRANSFORM256 IRONCLAD::H IRONCLAD::BUFFER 0))
;           (128 (IRONCLAD::KUPYNA-TRANSFORM512 IRONCLAD::H IRONCLAD::BUFFER 0)))
;         (SETF IRONCLAD::BUFFER-INDEX 0))
;       (FILL IRONCLAD::BUFFER 0 :START IRONCLAD::BUFFER-INDEX)
;       (SETF (IRONCLAD:UB64REF/LE IRONCLAD::BUFFER (- IRONCLAD:BLOCK-LENGTH 12))
;               IRONCLAD::TOTAL)
;       (ECASE IRONCLAD:BLOCK-LENGTH
;         (64
;          (IRONCLAD::KUPYNA-TRANSFORM256 IRONCLAD::H IRONCLAD::BUFFER 0)
;          (IRONCLAD::KUPYNA-OUTPUT-TRANSFORM256 IRONCLAD::H))
;         (128
;          (IRONCLAD::KUPYNA-TRANSFORM512 IRONCLAD::H IRONCLAD::BUFFER 0)
;          (IRONCLAD::KUPYNA-OUTPUT-TRANSFORM512 IRONCLAD::H)))
;       (LET ((IRONCLAD::OUTPUT (MAKE-ARRAY 128 :ELEMENT-TYPE '#)))
;         (DOTIMES (IRONCLAD::I 16) (SETF # #))
;         (REPLACE IRONCLAD::DIGEST IRONCLAD::OUTPUT :START1 IRONCLAD::DIGEST-START
;                  :START2 (- IRONCLAD:BLOCK-LENGTH IRONCLAD:DIGEST-LENGTH) :END2
;                  IRONCLAD:BLOCK-LENGTH)
;         IRONCLAD::DIGEST))
; 
; note: doing unsigned word to integer coercion (cost 20) to TOTAL


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/kupyna-tmpA60KLDKY.fasl
; compilation finished in 0:00:04.071
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/md2.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/md2.lisp
; in: DEFUN UPDATE-MD2-REGS
;     (+ IRONCLAD::I IRONCLAD::OFFSET)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a NUMBER, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a NUMBER, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       etc.

; in: DEFUN MD2-REGS-DIGEST
;     (+ IRONCLAD::START IRONCLAD::I)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       etc.

; in: DEFINE-DIGEST-FINALIZER (MD2 16)
;     (IRONCLAD::FINALIZE-REGISTERS IRONCLAD::STATE IRONCLAD::REGS)
; --> BLOCK FLET IRONCLAD::STUFF-REGISTERS BLOCK DOTIMES DO BLOCK LET TAGBODY 
; --> TAGBODY SETF SB-C::WITH-SOURCE-FORM AREF LET* 
; ==>
;   (+ IRONCLAD::START IRONCLAD::I)
; 
; 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.
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/md2-tmpD801X3GJ.fasl
; compilation finished in 0:00:00.090
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/md4.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/md4.lisp
; in: DEFINE-DIGEST-FINALIZER (MD4 16)
;     (* 8 (IRONCLAD::MD4-AMOUNT IRONCLAD::STATE))
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (IRONCLAD::STORE-DATA-LENGTH BLOCK IRONCLAD::TOTAL-LENGTH 14)
; --> BLOCK LET SETF PROGN SETF SB-C::WITH-SOURCE-FORM AREF LET* LDB 
; ==>
;   1
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline (unsigned-byte 64) arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/md4-tmpGOW1GC70.fasl
; compilation finished in 0:00:00.165
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/md5.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/md5.lisp
; in: DEFINE-DIGEST-FINALIZER (MD5 16)
;     (* 8 (IRONCLAD::MD5-AMOUNT IRONCLAD::STATE))
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (IRONCLAD::STORE-DATA-LENGTH BLOCK IRONCLAD::TOTAL-LENGTH 14)
; --> BLOCK LET SETF PROGN SETF SB-C::WITH-SOURCE-FORM AREF LET* LDB 
; ==>
;   1
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline (unsigned-byte 64) arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/md5-tmpPQ1X28TL.fasl
; compilation finished in 0:00:00.165
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/md5-lispworks-int32.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/md5-lispworks-int32-tmpE92ECU7O.fasl
; compilation finished in 0:00:00.002
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/ripemd-128.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/ripemd-128.lisp
; in: DEFINE-DIGEST-FINALIZER (RIPEMD-128 16)
;     (* 8 (IRONCLAD::RIPEMD-128-AMOUNT IRONCLAD::STATE))
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (IRONCLAD::STORE-DATA-LENGTH BLOCK IRONCLAD::TOTAL-LENGTH 14)
; --> BLOCK LET SETF PROGN SETF SB-C::WITH-SOURCE-FORM AREF LET* LDB 
; ==>
;   1
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline (unsigned-byte 64) arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/ripemd-128-tmp8S0II570.fasl
; compilation finished in 0:00:00.390
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/ripemd-160.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/ripemd-160.lisp
; in: DEFINE-DIGEST-FINALIZER (RIPEMD-160 20)
;     (* 8 (IRONCLAD::RIPEMD-160-AMOUNT IRONCLAD::STATE))
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (IRONCLAD::STORE-DATA-LENGTH BLOCK IRONCLAD::TOTAL-LENGTH 14)
; --> BLOCK LET SETF PROGN SETF SB-C::WITH-SOURCE-FORM AREF LET* LDB 
; ==>
;   1
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline (unsigned-byte 64) arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/ripemd-160-tmpJE88A12F.fasl
; compilation finished in 0:00:01.369
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/sha1.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/sha1.lisp
; in: DEFINE-DIGEST-FINALIZER (SHA1 20)
;     (* 8 (IRONCLAD::SHA1-AMOUNT IRONCLAD::STATE))
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (IRONCLAD::STORE-DATA-LENGTH BLOCK IRONCLAD::TOTAL-LENGTH 14 T)
; --> BLOCK LET SETF PROGN SETF SB-C::WITH-SOURCE-FORM AREF LET* LDB 
; ==>
;   1
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline (unsigned-byte 64) arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/sha1-tmpA5FNLPLT.fasl
; compilation finished in 0:00:00.090
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/sha256.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/sha256.lisp
; in: DEFINE-DIGEST-FINALIZER ((SHA256 32) (SHA224 28))
;     (* 8 (IRONCLAD::SHA256-AMOUNT IRONCLAD::STATE))
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (IRONCLAD::STORE-DATA-LENGTH BLOCK IRONCLAD::TOTAL-LENGTH 14 T)
; --> BLOCK LET SETF PROGN SETF SB-C::WITH-SOURCE-FORM AREF LET* LDB 
; ==>
;   1
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline (unsigned-byte 64) arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/sha256-tmpHKCV9TP8.fasl
; compilation finished in 0:00:00.989
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/sha3.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/sha3.lisp
; in: DEFUN GET-KECCAK-ROUND-CONSTANT
;     (DEFUN IRONCLAD::GET-KECCAK-ROUND-CONSTANT (IRONCLAD::I)
;       (DECLARE (TYPE (INTEGER 0 23) IRONCLAD::I)
;                (OPTIMIZE (SPEED 3) (SPACE 0) (SAFETY 0) (DEBUG 0)))
;       (LET ((IRONCLAD::CONSTANTS
;              (LOAD-TIME-VALUE IRONCLAD::+KECCAK-ROUND-CONSTANTS+ T)))
;         (DECLARE
;          (TYPE (SIMPLE-ARRAY IRONCLAD::KECCAK-LANE #) IRONCLAD::CONSTANTS))
;         (AREF IRONCLAD::CONSTANTS IRONCLAD::I)))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA IRONCLAD::GET-KECCAK-ROUND-CONSTANT
;         (IRONCLAD::I)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (TYPE (INTEGER 0 23) IRONCLAD::I)
;                (OPTIMIZE (SPEED 3) (SPACE 0) (SAFETY 0) (DEBUG 0)))
;       (BLOCK IRONCLAD::GET-KECCAK-ROUND-CONSTANT
;         (LET ((IRONCLAD::CONSTANTS #))
;           (DECLARE (TYPE # IRONCLAD::CONSTANTS))
;           (AREF IRONCLAD::CONSTANTS IRONCLAD::I))))
; 
; note: doing unsigned word to integer coercion (cost 20) to "<return value>"

; in: DEFUN SHA3-FINALIZE
;     (- IRONCLAD::OUTPUT-BYTE-LENGTH IRONCLAD::OUTPUT-SIZE)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (+ IRONCLAD::DIGEST-START IRONCLAD::OUTPUT-SIZE)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (INCF IRONCLAD::OUTPUT-SIZE IRONCLAD::N)
; ==>
;   (+ IRONCLAD::N IRONCLAD::OUTPUT-SIZE)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/sha3-tmpZ18MA7XE.fasl
; compilation finished in 0:00:00.369
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/sha512.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/sha512.lisp
; in: DEFUN UPDATE-SHA512-BLOCK
;     (IRONCLAD::MOD64+ (IRONCLAD::SHA512-REGS-H IRONCLAD::REGS) IRONCLAD::H)
; ==>
;   1
; 
; note: doing unsigned word to integer coercion (cost 20), for:
;       the first result of inline (unsigned-byte 64) arithmetic

; in: DEFINE-DIGEST-FINALIZER ((SHA512 64) (SHA384 48))
;     (* 8 (IRONCLAD::SHA512-AMOUNT IRONCLAD::STATE))
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/sha512-tmp6LQJ9T0C.fasl
; compilation finished in 0:00:00.532
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/skein.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/skein.lisp
; in: DEFUN SKEIN-UBI
;     (FUNCALL IRONCLAD::ENCRYPTION-FUNCTION IRONCLAD::CIPHER IRONCLAD::BUFFER 0
;              IRONCLAD::CIPHERTEXT 0)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   ENCRYPTION-FUNCTION is not known to be a function

;     (FUNCALL IRONCLAD::ENCRYPTION-FUNCTION IRONCLAD::CIPHER IRONCLAD::MESSAGE
;              IRONCLAD::MESSAGE-START IRONCLAD::CIPHERTEXT 0)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   ENCRYPTION-FUNCTION is not known to be a function


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/skein-tmpTX7OA81T.fasl
; compilation finished in 0:00:00.963
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/sm3.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/sm3.lisp
; in: DEFINE-DIGEST-UPDATER SM3
;     (INCF IRONCLAD::START 64)
; 
; note: doing signed word to integer coercion (cost 20) to START

; in: DEFINE-DIGEST-FINALIZER (SM3 32)
;     (* 8 (IRONCLAD::SM3-COUNT IRONCLAD::STATE))
; 
; note: forced to do */UNSIGNED=>INTEGER (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (UNSIGNED-BYTE 64), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0) (INTEGER 8 147573952589676412920))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (UNSIGNED-BYTE 64), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0) (INTEGER 8 147573952589676412920))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/sm3-tmpWOTC3PB7.fasl
; compilation finished in 0:00:03.098
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/streebog.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/streebog.lisp
; in: DEFUN STREEBOG-AX
;     (DEFUN IRONCLAD::STREEBOG-AX (IRONCLAD::I IRONCLAD::J)
;       (DECLARE (TYPE (INTEGER 0 7) IRONCLAD::I)
;                (TYPE (INTEGER 0 255) IRONCLAD::J)
;                (OPTIMIZE (SPEED 3) (SPACE 0) (SAFETY 0) (DEBUG 0)))
;       (LET ((IRONCLAD::CONSTANTS (LOAD-TIME-VALUE IRONCLAD::+STREEBOG-AX+ T)))
;         (DECLARE (TYPE (SIMPLE-ARRAY # #) IRONCLAD::CONSTANTS))
;         (AREF IRONCLAD::CONSTANTS IRONCLAD::I IRONCLAD::J)))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA IRONCLAD::STREEBOG-AX
;         (IRONCLAD::I IRONCLAD::J)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (TYPE (INTEGER 0 7) IRONCLAD::I)
;                (TYPE (INTEGER 0 255) IRONCLAD::J)
;                (OPTIMIZE (SPEED 3) (SPACE 0) (SAFETY 0) (DEBUG 0)))
;       (BLOCK IRONCLAD::STREEBOG-AX
;         (LET ((IRONCLAD::CONSTANTS #))
;           (DECLARE (TYPE # IRONCLAD::CONSTANTS))
;           (AREF IRONCLAD::CONSTANTS IRONCLAD::I IRONCLAD::J))))
; 
; note: doing unsigned word to integer coercion (cost 20) to "<return value>"

; in: DEFUN STREEBOG-STAGE2
;     (+ IRONCLAD::START (* IRONCLAD::I 8))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       etc.

; in: DEFINE-DIGEST-UPDATER STREEBOG
;     (INCF IRONCLAD::START 64)
; ==>
;   (+ 64 IRONCLAD::START)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/streebog-tmpHQE95SAC.fasl
; compilation finished in 0:00:00.857
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/tiger.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/tiger.lisp
; in: DEFCONSTANT +TIGER-BLOCK-COPY-FN+
;     'IRONCLAD::FILL-BLOCK-UB8-LE
; 
; note: deleting unreachable code

; in: DEFUN MAKE-TIGER-SBOX
;     (MAKE-ARRAY IRONCLAD::N-ELEMENTS :ELEMENT-TYPE '(UNSIGNED-BYTE 32)
;                 :INITIAL-CONTENTS IRONCLAD::ELEMENTS)
; 
; note: deleting unreachable code

; in: DEFINE-DIGEST-FINALIZER (TIGER 24)
;     (* 8 (IRONCLAD::TIGER-AMOUNT IRONCLAD::STATE))
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/tiger-tmpO87FP9NR.fasl
; compilation finished in 0:00:00.542
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/tree-hash.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/tree-hash-tmpP6A3E92I.fasl
; compilation finished in 0:00:00.054
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/digests/whirlpool.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/digests/whirlpool.lisp
; in: DEFINE-DIGEST-FINALIZER (WHIRLPOOL 64)
;     (* 8 (IRONCLAD::WHIRLPOOL-AMOUNT IRONCLAD::STATE))
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/digests/whirlpool-tmpUSHT8RIL.fasl
; compilation finished in 0:00:01.208
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/macs/blake2-mac.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/macs/blake2-mac-tmp7YCPD44Y.fasl
; compilation finished in 0:00:00.045
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/macs/blake2s-mac.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/macs/blake2s-mac-tmpQXR7SNXD.fasl
; compilation finished in 0:00:00.042
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/macs/cmac.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/macs/cmac.lisp
; in: DEFUN UPDATE-CMAC
;     (MIN IRONCLAD::REMAINING (- IRONCLAD:BLOCK-LENGTH IRONCLAD::BUFFER-INDEX))
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR
;                            (DOUBLE-FLOAT -1.7592186044414d13
;                             1.7592186044415d13)
;                            (SINGLE-FLOAT -1.7592186e13 1.7592186e13)
;                            (RATIONAL (-17592186044414)
;                                      (17592186044415))), not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR
;                            (DOUBLE-FLOAT -1.7592186044414d13
;                             1.7592186044415d13)
;                            (SINGLE-FLOAT -1.7592186e13 1.7592186e13)
;                            (RATIONAL (-17592186044414)
;                                      (17592186044415))), not a DOUBLE-FLOAT.

;     (= IRONCLAD::BUFFER-INDEX IRONCLAD:BLOCK-LENGTH)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (FUNCALL IRONCLAD::ENCRYPTION-FUNCTION IRONCLAD::CIPHER IRONCLAD::BUFFER 0
;              IRONCLAD::BUFFER 0)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   ENCRYPTION-FUNCTION is not known to be a function
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   ENCRYPTION-FUNCTION is not known to be a function

;     (- IRONCLAD:BLOCK-LENGTH IRONCLAD::BUFFER-INDEX)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (OR (RATIONAL (0) (17592186044415))
;                                    (SINGLE-FLOAT (0.0) (1.7592186e13))
;                                    (DOUBLE-FLOAT (0.0d0) (1.7592186044415d13))), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (DOUBLE-FLOAT -1.7592186044414d13 1.7592186044415d13)
;                         (SINGLE-FLOAT -1.7592186e13 1.7592186e13)
;                         (RATIONAL (-17592186044414) (17592186044415)))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (OR (RATIONAL (0) (17592186044415))
;                                    (SINGLE-FLOAT (0.0) (1.7592186e13))
;                                    (DOUBLE-FLOAT (0.0d0) (1.7592186044415d13))), not a (UNSIGNED-BYTE
;                                                                                         64).
;       The result is a (VALUES
;                        (OR
;                         (DOUBLE-FLOAT -1.7592186044414d13 1.7592186044415d13)
;                         (SINGLE-FLOAT -1.7592186e13 1.7592186e13)
;                         (RATIONAL (-17592186044414) (17592186044415)))
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (MIN IRONCLAD::REMAINING (- IRONCLAD:BLOCK-LENGTH IRONCLAD::BUFFER-INDEX))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (OR
;                                (DOUBLE-FLOAT -1.7592186044414d13
;                                 1.7592186044415d13)
;                                (SINGLE-FLOAT -1.7592186e13 1.7592186e13)
;                                (RATIONAL (-17592186044414) (17592186044415))), not a FIXNUM.

;     (DECF IRONCLAD::REMAINING)
; --> SB-IMPL::XSUBTRACT BLOCK 
; ==>
;   (- SB-IMPL::B SB-IMPL::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER * 17592186044415), not a FIXNUM.
;       The result is a (VALUES (INTEGER * 17592186044414) &OPTIONAL), not a (VALUES
;                                                                             FIXNUM
;                                                                             &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER * 17592186044415), not a FIXNUM.
;       The result is a (VALUES (INTEGER * 17592186044414) &OPTIONAL), not a (VALUES
;                                                                             FIXNUM
;                                                                             &OPTIONAL).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/macs/cmac-tmp6FLI1OC3.fasl
; compilation finished in 0:00:00.057
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/macs/hmac.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/macs/hmac-tmpWBK8JTS9.fasl
; compilation finished in 0:00:00.094
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/macs/gmac.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/macs/gmac.lisp
; in: DEFUN UPDATE-GMAC
;     (IRONCLAD::GMAC-TOTAL-LENGTH IRONCLAD::MAC)
; ==>
;   IRONCLAD::TOTAL-LENGTH
; 
; note: doing unsigned word to integer coercion (cost 20) from TOTAL-LENGTH


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/macs/gmac-tmpUVEUD2ZN.fasl
; compilation finished in 0:00:00.724
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/macs/poly1305.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/macs/poly1305-tmpOWNJOEU.fasl
; compilation finished in 0:00:00.080
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/macs/siphash.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/macs/siphash-tmpVT5BMTA5.fasl
; compilation finished in 0:00:00.078
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/macs/skein-mac.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/macs/skein-mac-tmpN3CFVWZF.fasl
; compilation finished in 0:00:00.035
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/prng/generator.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/prng/generator-tmpNK27C0R1.fasl
; compilation finished in 0:00:00.017
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/prng/fortuna.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/prng/fortuna-tmp3BPE71HR.fasl
; compilation finished in 0:00:00.027
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/aead/eax.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/aead/eax-tmp758YUXMV.fasl
; compilation finished in 0:00:00.101
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/aead/etm.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/aead/etm-tmpGMQXK1HK.fasl
; compilation finished in 0:00:00.051
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/aead/gcm.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/aead/gcm-tmp49Q238TW.fasl
; compilation finished in 0:00:00.048
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/kdf/argon2.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/kdf/argon2-tmpMXPMJ5KG.fasl
; compilation finished in 0:00:04.172
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/kdf/bcrypt.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/kdf/bcrypt-tmpB69313KI.fasl
; compilation finished in 0:00:00.072
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/kdf/hmac.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/kdf/hmac-tmp9ZT99EEA.fasl
; compilation finished in 0:00:00.041
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/kdf/pkcs5.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/kdf/pkcs5-tmpW045U8V2.fasl
; compilation finished in 0:00:00.022
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/kdf/password-hash.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/kdf/password-hash-tmp6XOIRI3N.fasl
; compilation finished in 0:00:00.022
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/kdf/scrypt.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/kdf/scrypt-tmp9ZHTLHSG.fasl
; compilation finished in 0:00:00.048
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/dsa.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/dsa-tmpRW73Q691.fasl
; compilation finished in 0:00:00.063
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/rsa.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/rsa-tmp4TM0ME1F.fasl
; compilation finished in 0:00:00.059
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/elgamal.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/elgamal-tmpU2IL9N4.fasl
; compilation finished in 0:00:00.063
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/curve25519.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/public-key/curve25519.lisp
; in: DEFUN CURVE25519-DOUBLE-AND-ADD
;     (+ IRONCLAD::X1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::T1 IRONCLAD::T1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::X1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::T3 IRONCLAD::T3)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::T2 IRONCLAD::T4)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -57896044618658097711785492504343953926634992332820282019728792003956564819948
;                         57896044618658097711785492504343953926634992332820282019728792003956564819948)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -57896044618658097711785492504343953926634992332820282019728792003956564819948
;                         57896044618658097711785492504343953926634992332820282019728792003956564819948)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ IRONCLAD::X2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- IRONCLAD::X2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::T1 IRONCLAD::T7)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::T3 IRONCLAD::T6)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ IRONCLAD::T8 IRONCLAD::T9)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         115792089237316195423570985008687907853269984665640564039457584007913129639897)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         115792089237316195423570985008687907853269984665640564039457584007913129639897)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::T8 IRONCLAD::T9)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -57896044618658097711785492504343953926634992332820282019728792003956564819948
;                         57896044618658097711785492504343953926634992332820282019728792003956564819948)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -57896044618658097711785492504343953926634992332820282019728792003956564819948
;                         57896044618658097711785492504343953926634992332820282019728792003956564819948)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::T2 IRONCLAD::T4)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::T5 IRONCLAD::+CURVE25519-A24+)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 121666
;                             7043980164573656116202093731033511498437972977164912432212323207953379415383793368))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 121666
;                             7043980164573656116202093731033511498437972977164912432212323207953379415383793368))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (+ IRONCLAD::T4 IRONCLAD::T12)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         115792089237316195423570985008687907853269984665640564039457584007913129639897)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         115792089237316195423570985008687907853269984665640564039457584007913129639897)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::T5 IRONCLAD::T13)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::T10 IRONCLAD::T10)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::T11 IRONCLAD::T11)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::X3 IRONCLAD::T14)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-DECODE-SCALAR ((EQL :CURVE25519) T)
;     (LDB (BYTE (1- IRONCLAD::+CURVE25519-BITS+) 0)
;          (IRONCLAD:OCTETS-TO-INTEGER IRONCLAD::OCTETS :BIG-ENDIAN NIL))
; 
; note: unable to
;   convert to inline logical operations
; due to type uncertainty:
;   The result is a (VALUES (UNSIGNED-BYTE 255) &OPTIONAL), not a (VALUES
;                                                                  (UNSIGNED-BYTE
;                                                                   64)
;                                                                  &REST T).

;     (LDB (BYTE 3 0) IRONCLAD::X)
; --> SETQ DPB 
; ==>
;   1
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (UNSIGNED-BYTE 255), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         57896044618658097711785492504343953926634992332820282019728792003956564819961)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (UNSIGNED-BYTE 255), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         57896044618658097711785492504343953926634992332820282019728792003956564819961)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/curve25519-tmpOPW41KDL.fasl
; compilation finished in 0:00:00.047
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/curve448.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/public-key/curve448.lisp
; in: DEFUN CURVE448-DOUBLE-AND-ADD
;     (+ IRONCLAD::X1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- IRONCLAD::X1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- IRONCLAD::X2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::T1 IRONCLAD::T3)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ IRONCLAD::X2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::T2 IRONCLAD::T5)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::T4 IRONCLAD::T6)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (INTEGER
;                         -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::T7 IRONCLAD::T7)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::X3 IRONCLAD::T8)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (+ IRONCLAD::T4 IRONCLAD::T6)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730877)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730877)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::T9 IRONCLAD::T9)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::T1 IRONCLAD::T1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::T2 IRONCLAD::T2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::T10 IRONCLAD::T11)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::T10 IRONCLAD::T11)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (INTEGER
;                         -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::T12 IRONCLAD::+CURVE448-A24+)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 39081
;                             28405584184196612889558123736071105207074658017021077113860918474177510397084005327357057071327978091493803693653311191707331756055739682478))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 39081
;                             28405584184196612889558123736071105207074658017021077113860918474177510397084005327357057071327978091493803693653311191707331756055739682478))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (+ IRONCLAD::T13 IRONCLAD::T10)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730877)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730877)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::T14 IRONCLAD::T12)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-DECODE-SCALAR ((EQL :CURVE448) T)
;     (LDB (BYTE IRONCLAD::+CURVE448-BITS+ 0)
;          (IRONCLAD:OCTETS-TO-INTEGER IRONCLAD::OCTETS :BIG-ENDIAN NIL))
; 
; note: unable to
;   convert to inline logical operations
; due to type uncertainty:
;   The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                            (UNSIGNED-BYTE 64)
;                                                            &REST T).

;     (LDB (BYTE 2 0) IRONCLAD::X)
; --> SETQ DPB 
; ==>
;   1
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/curve448-tmpIPVWLON2.fasl
; compilation finished in 0:00:00.044
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/ed25519.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/public-key/ed25519.lisp
; in: DEFUN ED25519-RECOVER-X
;     (MOD
;      (* IRONCLAD::UV3
;         (IRONCLAD:EXPT-MOD IRONCLAD::UV7 (/ (- IRONCLAD::+ED25519-Q+ 5) 8)
;                            IRONCLAD::+ED25519-Q+))
;      IRONCLAD::+ED25519-Q+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (* IRONCLAD::Y IRONCLAD::Y)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

;     (1- (* IRONCLAD::Y IRONCLAD::Y))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER -1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                      &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER -1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                      &OPTIONAL).
;       etc.

;     (1+ IRONCLAD::U)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER 1
;                         57896044618658097711785492504343953926634992332820282019728792003956564819949)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER 1
;                         57896044618658097711785492504343953926634992332820282019728792003956564819949)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* IRONCLAD::V IRONCLAD::V IRONCLAD::V)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         194064761537588616893622436057812819407110752139587076392381504753256369085595993672410662147087199368837878645229193663462561604848498377274709448929113913002071147247356829369437895575864476831150950995459034595069848999419699393)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                    64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         194064761537588616893622436057812819407110752139587076392381504753256369085595993672410662147087199368837878645229193663462561604848498377274709448929113913002071147247356829369437895575864476831150950995459034595069848999419699393)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::U IRONCLAD::V3)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::UV3 IRONCLAD::V3 IRONCLAD::V)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         194064761537588616893622436057812819407110752139587076392381504753256369085595993672410662147087199368837878645229193663462561604848498377274709448929113913002071147247356829369437895575864476831150950995459034595069848999419699393)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                    64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         194064761537588616893622436057812819407110752139587076392381504753256369085595993672410662147087199368837878645229193663462561604848498377274709448929113913002071147247356829369437895575864476831150950995459034595069848999419699393)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::UV3
;        (IRONCLAD:EXPT-MOD IRONCLAD::UV7 (/ (- IRONCLAD::+ED25519-Q+ 5) 8)
;                           IRONCLAD::+ED25519-Q+))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

;     (* IRONCLAD::V IRONCLAD::X IRONCLAD::X)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         194064761537588616893622436057812819407110752139587076392381504753256369085595993672410662147087199368837878645229193663462561604848498377274709448929113913002071147247356829369437895575864476831150950995459034595069848999419699393)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                    64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         194064761537588616893622436057812819407110752139587076392381504753256369085595993672410662147087199368837878645229193663462561604848498377274709448929113913002071147247356829369437895575864476831150950995459034595069848999419699393)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-ADD (ED25519-POINT ED25519-POINT)
;     (- IRONCLAD::Y1 IRONCLAD::X1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- IRONCLAD::Y2 IRONCLAD::X2)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* (- IRONCLAD::Y1 IRONCLAD::X1) (- IRONCLAD::Y2 IRONCLAD::X2))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (+ IRONCLAD::Y1 IRONCLAD::X1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (+ IRONCLAD::Y2 IRONCLAD::X2)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* (+ IRONCLAD::Y1 IRONCLAD::X1) (+ IRONCLAD::Y2 IRONCLAD::X2))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::W1 IRONCLAD::W2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* 2 IRONCLAD::Z1 IRONCLAD::Z2)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -2) (INTEGER 0 0) (INTEGER 2))
;                               &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -2) (INTEGER 0 0) (INTEGER 2))
;                               &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (INTEGER * -2) (INTEGER 0 0) (INTEGER 2)), not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (INTEGER * -2) (INTEGER 0 0) (INTEGER 2)), not a (UNSIGNED-BYTE
;                                                                                     64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- IRONCLAD::B IRONCLAD::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -57896044618658097711785492504343953926634992332820282019728792003956564819948
;                         57896044618658097711785492504343953926634992332820282019728792003956564819948)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -57896044618658097711785492504343953926634992332820282019728792003956564819948
;                         57896044618658097711785492504343953926634992332820282019728792003956564819948)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::D IRONCLAD::C)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -57896044618658097711785492504343953926634992332820282019728792003956564819948
;                         57896044618658097711785492504343953926634992332820282019728792003956564819948)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -57896044618658097711785492504343953926634992332820282019728792003956564819948
;                         57896044618658097711785492504343953926634992332820282019728792003956564819948)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ IRONCLAD::D IRONCLAD::C)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         115792089237316195423570985008687907853269984665640564039457584007913129639897)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         115792089237316195423570985008687907853269984665640564039457584007913129639897)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ IRONCLAD::B IRONCLAD::A)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         115792089237316195423570985008687907853269984665640564039457584007913129639897)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         115792089237316195423570985008687907853269984665640564039457584007913129639897)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::E IRONCLAD::F)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::G IRONCLAD::H)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::F IRONCLAD::G)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::E IRONCLAD::H)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-DOUBLE (ED25519-POINT)
;     (* IRONCLAD::X1 IRONCLAD::X1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1 IRONCLAD::Y1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* 2 IRONCLAD::Z1 IRONCLAD::Z1)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -2) (INTEGER 0 0) (INTEGER 2))
;                               &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -2) (INTEGER 0 0) (INTEGER 2))
;                               &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (INTEGER * -2) (INTEGER 0 0) (INTEGER 2)), not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (INTEGER * -2) (INTEGER 0 0) (INTEGER 2)), not a (UNSIGNED-BYTE
;                                                                                     64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (+ IRONCLAD::X1 IRONCLAD::Y1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::D IRONCLAD::D)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ IRONCLAD::A IRONCLAD::B)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         115792089237316195423570985008687907853269984665640564039457584007913129639897)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         115792089237316195423570985008687907853269984665640564039457584007913129639897)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::H IRONCLAD::I)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -57896044618658097711785492504343953926634992332820282019728792003956564819948
;                         57896044618658097711785492504343953926634992332820282019728792003956564819948)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -57896044618658097711785492504343953926634992332820282019728792003956564819948
;                         57896044618658097711785492504343953926634992332820282019728792003956564819948)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::A IRONCLAD::B)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -57896044618658097711785492504343953926634992332820282019728792003956564819948
;                         57896044618658097711785492504343953926634992332820282019728792003956564819948)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -57896044618658097711785492504343953926634992332820282019728792003956564819948
;                         57896044618658097711785492504343953926634992332820282019728792003956564819948)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ IRONCLAD::C IRONCLAD::G)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         115792089237316195423570985008687907853269984665640564039457584007913129639897)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         115792089237316195423570985008687907853269984665640564039457584007913129639897)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::E IRONCLAD::F)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::G IRONCLAD::H)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::F IRONCLAD::G)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::E IRONCLAD::H)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         3351951982485649274893506249551461531869841455148098344430890360930441007516070902415722250633254437222334206389556113020125659422197490806450149658722705)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-POINT-ON-CURVE-P (ED25519-POINT)
;     (* IRONCLAD::X IRONCLAD::X)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y IRONCLAD::Y)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z IRONCLAD::Z)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::W IRONCLAD::W)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- IRONCLAD::YY IRONCLAD::XX)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -57896044618658097711785492504343953926634992332820282019728792003956564819948
;                         57896044618658097711785492504343953926634992332820282019728792003956564819948)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -57896044618658097711785492504343953926634992332820282019728792003956564819948
;                         57896044618658097711785492504343953926634992332820282019728792003956564819948)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ IRONCLAD::ZZ (* IRONCLAD::+ED25519-D+ IRONCLAD::WW))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER
;                                     37095705934669439343138083508754565189542113879843219016388785533085940283555
;                                     2147694645954241852484040567486267188178402270445892907140121793157764114386211238650957099786829249829777408518992270436843721382558176074814068640355140)), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         2147694645954241852484040567486267188178402270445892907140121793157764114386269134695575757884541035322281752472918905429176541664577904866818025205175089)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER
;                                     37095705934669439343138083508754565189542113879843219016388785533085940283555
;                                     2147694645954241852484040567486267188178402270445892907140121793157764114386211238650957099786829249829777408518992270436843721382558176074814068640355140)), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                          64).
;       The result is a (VALUES
;                        (MOD
;                         2147694645954241852484040567486267188178402270445892907140121793157764114386269134695575757884541035322281752472918905429176541664577904866818025205175089)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::A IRONCLAD::B)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -57896044618658097711785492504343953926634992332820282019728792003956564819948
;                         57896044618658097711785492504343953926634992332820282019728792003956564819948)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The second argument is a (MOD
;                                 57896044618658097711785492504343953926634992332820282019728792003956564819949), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -57896044618658097711785492504343953926634992332820282019728792003956564819948
;                         57896044618658097711785492504343953926634992332820282019728792003956564819948)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-POINT-EQUAL (ED25519-POINT ED25519-POINT)
;     (* IRONCLAD::X1 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X2 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::X1 IRONCLAD::Z2) (* IRONCLAD::X2 IRONCLAD::Z1))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y2 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::Y1 IRONCLAD::Z2) (* IRONCLAD::Y2 IRONCLAD::Z1))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

; in: DEFUN ED25519-PUBLIC-KEY
;     (SUBSEQ IRONCLAD::H 0 (/ IRONCLAD::+ED25519-BITS+ 8))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (LDB (BYTE 3 0) (ELT IRONCLAD::H 0))
; --> LET DPB 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.

; --> LET 
; ==>
;   (SB-KERNEL:%SETELT #:H1 0 #:NEW0)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
;                                                                    * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.

;     (LDB (BYTE 2 6) (ELT IRONCLAD::H (- (/ IRONCLAD::+ED25519-BITS+ 8) 1)))
; --> LET DPB 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.
; 
; note: unable to
;   convert to inline logical operations
; due to type uncertainty:
;   The result is a (VALUES (OR (INTEGER * -1) (INTEGER 64))
;                           &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
; 
; note: unable to
;   convert to inline logical operations
; due to type uncertainty:
;   The result is a (VALUES (OR (INTEGER * -1) (INTEGER 64))
;                           &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

; --> LET 
; ==>
;   (SB-KERNEL:%SETELT #:H4 (- (/ IRONCLAD::+ED25519-BITS+ 8) 1) #:NEW3)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY
;                                                                    * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS
;                               SB-KERNEL:EXTENDED-SEQUENCE), not a LIST.

;     (LDB (BYTE 3 0) (ELT IRONCLAD::H 0))
; --> LET DPB 
; ==>
;   1
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       etc.

; in: DEFUN ED25519-SIGN
;     (LDB (BYTE 3 0) (ELT IRONCLAD::H 0))
; --> LET DPB 
; ==>
;   1
; 
; 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.

; --> LET 
; ==>
;   (SB-KERNEL:%SETELT #:H1 0 #:NEW0)
; 
; 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.

;     (LDB (BYTE 2 6) (ELT IRONCLAD::H (- (/ IRONCLAD::+ED25519-BITS+ 8) 1)))
; --> LET DPB 
; ==>
;   1
; 
; 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.
; 
; note: unable to
;   convert to inline logical operations
; due to type uncertainty:
;   The result is a (VALUES (OR (INTEGER * -1) (INTEGER 64))
;                           &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
; 
; note: unable to
;   convert to inline logical operations
; due to type uncertainty:
;   The result is a (VALUES (OR (INTEGER * -1) (INTEGER 64))
;                           &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).

; --> LET 
; ==>
;   (SB-KERNEL:%SETELT #:H4 (- (/ IRONCLAD::+ED25519-BITS+ 8) 1) #:NEW3)
; 
; 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.

;     (SUBSEQ IRONCLAD::H 0 (/ IRONCLAD::+ED25519-BITS+ 8))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (SUBSEQ IRONCLAD::H (/ IRONCLAD::+ED25519-BITS+ 8)
;             (/ IRONCLAD::+ED25519-BITS+ 4))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (MOD (IRONCLAD:EC-DECODE-SCALAR :ED25519 IRONCLAD::RH) IRONCLAD::+ED25519-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (MOD
;      (IRONCLAD:EC-DECODE-SCALAR :ED25519
;                                 (IRONCLAD::ED25519-HASH IRONCLAD::RP IRONCLAD::PK
;                                  IRONCLAD::M))
;      IRONCLAD::+ED25519-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (LDB (BYTE 3 0) (ELT IRONCLAD::H 0))
; --> LET DPB 
; ==>
;   1
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       etc.

;     (* IRONCLAD::K IRONCLAD::A)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                7237005577332262213973186563042994240857116359379907606001950938285454250989), not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                7237005577332262213973186563042994240857116359379907606001950938285454250989), not a (UNSIGNED-BYTE
;                                                                                                                      64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (+ (* IRONCLAD::K IRONCLAD::A) IRONCLAD::RI)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 7237005577332262213973186563042994240857116359379907606001950938285454250989), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 7237005577332262213973186563042994240857116359379907606001950938285454250989), not a (UNSIGNED-BYTE
;                                                                                                                       64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

; in: DEFUN ED25519-VERIFY
;     (MOD
;      (IRONCLAD:EC-DECODE-SCALAR :ED25519
;                                 (IRONCLAD::ED25519-HASH IRONCLAD::R IRONCLAD::PK
;                                  IRONCLAD::M))
;      IRONCLAD::+ED25519-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/ed25519-tmpO0LCOIDS.fasl
; compilation finished in 0:00:00.091
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/ed448.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/public-key/ed448.lisp
; in: DEFUN ED448-RECOVER-X
;     (MOD
;      (* IRONCLAD::U3V
;         (IRONCLAD:EXPT-MOD IRONCLAD::U5V3 (/ (- IRONCLAD::+ED448-Q+ 3) 4)
;                            IRONCLAD::+ED448-Q+))
;      IRONCLAD::+ED448-Q+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (* IRONCLAD::Y IRONCLAD::Y)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

;     (1- (* IRONCLAD::Y IRONCLAD::Y))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER -1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                      &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER -1) &OPTIONAL), not a (VALUES FIXNUM
;                                                                      &OPTIONAL).
;       etc.

;     (1+ IRONCLAD::U)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER 1
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER 1
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* IRONCLAD::+ED448-D+ (1+ IRONCLAD::U))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER 1
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -28405584184196612889558123736071105207074658017021077113860918474177510397084005327357057071327978091493803693653311191707331756055739721559
;                         -39081)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -28405584184196612889558123736071105207074658017021077113860918474177510397084005327357057071327978091493803693653311191707331756055739721559
;                         -39081)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (1- (* IRONCLAD::+ED448-D+ (1+ IRONCLAD::U)))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER
;                                -28405584184196612889558123736071105207074658017021077113860918474177510397084005327357057071327978091493803693653311191707331756055739721559
;                                -39081), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -28405584184196612889558123736071105207074658017021077113860918474177510397084005327357057071327978091493803693653311191707331756055739721560
;                         -39082)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -28405584184196612889558123736071105207074658017021077113860918474177510397084005327357057071327978091493803693653311191707331756055739721559
;                                -39081), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -28405584184196612889558123736071105207074658017021077113860918474177510397084005327357057071327978091493803693653311191707331756055739721560
;                         -39082)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* IRONCLAD::U IRONCLAD::V)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::U IRONCLAD::U IRONCLAD::UV)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         383984923062992702193107238768305990575971314802788874095145673202033267015866160824156542228134514790183983507016891440783606607878560120446759002880024553793796781079076555940582389267580537359243311262284327013495014833399929662539661053437671746996921499531190282669815840119244221198707642915966992579932173647238953260602561484622551570055889936319200163724829307589544003296741511201335648379207673)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                                                        64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         383984923062992702193107238768305990575971314802788874095145673202033267015866160824156542228134514790183983507016891440783606607878560120446759002880024553793796781079076555940582389267580537359243311262284327013495014833399929662539661053437671746996921499531190282669815840119244221198707642915966992579932173647238953260602561484622551570055889936319200163724829307589544003296741511201335648379207673)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::U3V IRONCLAD::UV IRONCLAD::UV)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         383984923062992702193107238768305990575971314802788874095145673202033267015866160824156542228134514790183983507016891440783606607878560120446759002880024553793796781079076555940582389267580537359243311262284327013495014833399929662539661053437671746996921499531190282669815840119244221198707642915966992579932173647238953260602561484622551570055889936319200163724829307589544003296741511201335648379207673)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                                                        64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         383984923062992702193107238768305990575971314802788874095145673202033267015866160824156542228134514790183983507016891440783606607878560120446759002880024553793796781079076555940582389267580537359243311262284327013495014833399929662539661053437671746996921499531190282669815840119244221198707642915966992579932173647238953260602561484622551570055889936319200163724829307589544003296741511201335648379207673)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::U3V
;        (IRONCLAD:EXPT-MOD IRONCLAD::U5V3 (/ (- IRONCLAD::+ED448-Q+ 3) 4)
;                           IRONCLAD::+ED448-Q+))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-ADD (ED448-POINT ED448-POINT)
;     (* IRONCLAD::Z1 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::A IRONCLAD::A)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::X1 IRONCLAD::X2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1 IRONCLAD::Y2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::C IRONCLAD::D)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::+ED448-D+ IRONCLAD::K)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -28405584184196612889558123736071105207074658017021077113860918474177510397084005327357057071327978091493803693653311191707331756055739682478
;                          -39081)
;                         (INTEGER 0 0))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -28405584184196612889558123736071105207074658017021077113860918474177510397084005327357057071327978091493803693653311191707331756055739682478
;                          -39081)
;                         (INTEGER 0 0))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- IRONCLAD::B IRONCLAD::E)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (INTEGER
;                         -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ IRONCLAD::B IRONCLAD::E)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730877)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730877)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ IRONCLAD::X1 IRONCLAD::Y1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (+ IRONCLAD::X2 IRONCLAD::Y2)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* (+ IRONCLAD::X1 IRONCLAD::Y1) (+ IRONCLAD::X2 IRONCLAD::Y2))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::A IRONCLAD::F)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::A IRONCLAD::G)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::H IRONCLAD::C IRONCLAD::D)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (INTEGER
;                         -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730876
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (INTEGER
;                         -1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730876
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::I (- IRONCLAD::H IRONCLAD::C IRONCLAD::D))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (INTEGER
;                                 -1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730876
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -1056589062271330492704679569833033213037694652072243044255921418053269422980479201469843346168891949555676434277992307502384960470195505587607667379354705268932983924615864005053696928706219547972793749003012586215908533357561963574307900580771586667654529483074625863688
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931844)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (INTEGER
;                                 -1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730876
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (INTEGER
;                         -1056589062271330492704679569833033213037694652072243044255921418053269422980479201469843346168891949555676434277992307502384960470195505587607667379354705268932983924615864005053696928706219547972793749003012586215908533357561963574307900580771586667654529483074625863688
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931844)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::D IRONCLAD::C)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (INTEGER
;                         -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::J (- IRONCLAD::D IRONCLAD::C))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (INTEGER
;                                 -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931844
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931844)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (INTEGER
;                                 -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (INTEGER
;                         -528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931844
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931844)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::F IRONCLAD::G)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-DOUBLE (ED448-POINT)
;     (+ IRONCLAD::X1 IRONCLAD::Y1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::A IRONCLAD::A)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::X1 IRONCLAD::X1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1 IRONCLAD::Y1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (+ IRONCLAD::C IRONCLAD::D)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730877)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730877)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* 2 IRONCLAD::F)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730876))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730876))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- IRONCLAD::E (* 2 IRONCLAD::F))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 2
;                                     1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730876)), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730876
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 2
;                                     1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730876)), not a (UNSIGNED-BYTE
;                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730876
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::B IRONCLAD::E)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (INTEGER
;                         -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* (- IRONCLAD::B IRONCLAD::E) IRONCLAD::G)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931844
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931844)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (INTEGER
;                         -528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931844
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931844)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::C IRONCLAD::D)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (INTEGER
;                         -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* (- IRONCLAD::C IRONCLAD::D) IRONCLAD::E)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931844
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931844)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (INTEGER
;                         -528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931844
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931844)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::E IRONCLAD::G)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-POINT-ON-CURVE-P (ED448-POINT)
;     (* IRONCLAD::X IRONCLAD::X)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y IRONCLAD::Y)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z IRONCLAD::Z)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::ZZ IRONCLAD::ZZ)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         528294531135665246352339784916516606518847326036121522127960709026634711490239600734921673084445974777838217138996153751192480235097752793803833689677352634466491962307932002526848464353109773986396874501506293107954266678780981787153950290385793333827264741537312931845)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ IRONCLAD::YY IRONCLAD::XX)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730877)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (MOD
;                         1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730877)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::ZZ (+ IRONCLAD::YY IRONCLAD::XX))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730877), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         1056589062271330492704679569833033213037694652072243044255921418053269422980479201469843346168891949555676434277992307502384960470195505587607667379354705268932983924615864005053696928706219547972793749003012586215908533357561963574307900580771586667654529483074625863689)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 1453677448591213781098647615776009068707282721374636120562980398361224656333461545372792767397353091860177768923687274722106996036730877), not a (UNSIGNED-BYTE
;                                                                                                                                                                                   64).
;       The result is a (VALUES
;                        (MOD
;                         1056589062271330492704679569833033213037694652072243044255921418053269422980479201469843346168891949555676434277992307502384960470195505587607667379354705268932983924615864005053696928706219547972793749003012586215908533357561963574307900580771586667654529483074625863689)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::+ED448-D+ IRONCLAD::XX IRONCLAD::YY)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -28405584184196612889558123736071105207074658017021077113860918474177510397084005327357057071327978091493803693653311191707331756055739682478
;                          -39081)
;                         (INTEGER 0 0))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -28405584184196612889558123736071105207074658017021077113860918474177510397084005327357057071327978091493803693653311191707331756055739682478
;                          -39081)
;                         (INTEGER 0 0))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR
;                                (INTEGER
;                                 -28405584184196612889558123736071105207074658017021077113860918474177510397084005327357057071327978091493803693653311191707331756055739682478
;                                 -39081)
;                                (INTEGER 0 0)), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES (INTEGER * 0) &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR
;                                (INTEGER
;                                 -28405584184196612889558123736071105207074658017021077113860918474177510397084005327357057071327978091493803693653311191707331756055739682478
;                                 -39081)
;                                (INTEGER 0 0)), not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES (INTEGER * 0) &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

;     (+ IRONCLAD::ZZZZ (* IRONCLAD::+ED448-D+ IRONCLAD::XX IRONCLAD::YY))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (INTEGER * 0), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER *
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (INTEGER * 0), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER *
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::A IRONCLAD::B)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                 64).
;       The second argument is a (MOD
;                                 726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365439), not a (UNSIGNED-BYTE
;                                                                                                                                                                                  64).
;       The result is a (VALUES
;                        (INTEGER
;                         -726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438
;                         726838724295606890549323807888004534353641360687318060281490199180612328166730772686396383698676545930088884461843637361053498018365438)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-POINT-EQUAL (ED448-POINT ED448-POINT)
;     (* IRONCLAD::X1 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X2 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::X1 IRONCLAD::Z2) (* IRONCLAD::X2 IRONCLAD::Z1))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y2 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::Y1 IRONCLAD::Z2) (* IRONCLAD::Y2 IRONCLAD::Z1))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

; in: DEFUN ED448-SIGN
;     (LDB (BYTE 2 0) (ELT IRONCLAD::H 0))
; --> LET DPB 
; ==>
;   1
; 
; 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.

; --> LET 
; ==>
;   (SB-KERNEL:%SETELT #:H1 0 #:NEW0)
; 
; 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.

;     (LDB (BYTE 1 7) (ELT IRONCLAD::H (- (CEILING IRONCLAD::+ED448-BITS+ 8) 2)))
; --> LET DPB 
; ==>
;   1
; 
; 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.

; --> LET 
; ==>
;   (SB-KERNEL:%SETELT #:H4 (- (CEILING IRONCLAD::+ED448-BITS+ 8) 2) #:NEW3)
; 
; 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.

;     (ELT IRONCLAD::H (- (CEILING IRONCLAD::+ED448-BITS+ 8) 1))
; 
; 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.

;     (SUBSEQ IRONCLAD::H 0 (CEILING IRONCLAD::+ED448-BITS+ 8))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (SUBSEQ IRONCLAD::H (CEILING IRONCLAD::+ED448-BITS+ 8)
;             (CEILING IRONCLAD::+ED448-BITS+ 4))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (MOD (IRONCLAD:EC-DECODE-SCALAR :ED448 IRONCLAD::RH) IRONCLAD::+ED448-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (MOD
;      (IRONCLAD:EC-DECODE-SCALAR :ED448
;                                 (IRONCLAD::ED448-HASH IRONCLAD::+ED448-DOM+
;                                  IRONCLAD::RP IRONCLAD::PK IRONCLAD::M))
;      IRONCLAD::+ED448-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (MOD (+ (* IRONCLAD::K IRONCLAD::A) IRONCLAD::RI) IRONCLAD::+ED448-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (LDB (BYTE 2 0) (ELT IRONCLAD::H 0))
; --> LET DPB 
; ==>
;   1
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       etc.

;     (LDB (BYTE 1 7) (ELT IRONCLAD::H (- (CEILING IRONCLAD::+ED448-BITS+ 8) 2)))
; --> LET DPB 
; ==>
;   1
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -1) (INTEGER 128)) &OPTIONAL), not a (VALUES
;                                                                                    FIXNUM
;                                                                                    &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -1) (INTEGER 128)) &OPTIONAL), not a (VALUES
;                                                                                    FIXNUM
;                                                                                    &OPTIONAL).
;       etc.

;     (* IRONCLAD::K IRONCLAD::A)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR FLOAT
;                                   (RATIONAL 0
;                                             (181709681073901722637330951972001133588410340171829515070372549795146003961539585716195755291692375963310293709091662304773755859649779))), not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR FLOAT
;                                   (RATIONAL 0
;                                             (181709681073901722637330951972001133588410340171829515070372549795146003961539585716195755291692375963310293709091662304773755859649779))), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

;     (+ (* IRONCLAD::K IRONCLAD::A) IRONCLAD::RI)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a (OR FLOAT
;                                    (RATIONAL 0
;                                              (181709681073901722637330951972001133588410340171829515070372549795146003961539585716195755291692375963310293709091662304773755859649779))), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a (OR FLOAT
;                                    (RATIONAL 0
;                                              (181709681073901722637330951972001133588410340171829515070372549795146003961539585716195755291692375963310293709091662304773755859649779))), not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                              &OPTIONAL).
;       etc.

; in: DEFUN ED448-VERIFY
;     (MOD
;      (IRONCLAD:EC-DECODE-SCALAR :ED448
;                                 (IRONCLAD::ED448-HASH IRONCLAD::+ED448-DOM+
;                                  IRONCLAD::R IRONCLAD::PK IRONCLAD::M))
;      IRONCLAD::+ED448-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/ed448-tmpP264WQ6O.fasl
; compilation finished in 0:00:00.107
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/secp256k1.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/public-key/secp256k1.lisp
; in: DEFMETHOD EC-POINT-EQUAL (SECP256K1-POINT SECP256K1-POINT)
;     (* IRONCLAD::Z1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X1 IRONCLAD::Z2Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X2 IRONCLAD::Z1Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::X1 IRONCLAD::Z2Z2) (* IRONCLAD::X2 IRONCLAD::Z1Z1))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1 IRONCLAD::Z2Z2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y2 IRONCLAD::Z1Z1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::Y1 IRONCLAD::Z2Z2 IRONCLAD::Z2)
;        (* IRONCLAD::Y2 IRONCLAD::Z1Z1 IRONCLAD::Z1))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-DOUBLE (SECP256K1-POINT)
;     (* IRONCLAD::X1 IRONCLAD::X1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1 IRONCLAD::Y1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::B IRONCLAD::B)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ IRONCLAD::X1 IRONCLAD::B)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X1+B IRONCLAD::X1+B)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::X1+B IRONCLAD::X1+B) IRONCLAD::A IRONCLAD::C)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -231584178474632390847141970017375815706539969331281128078915168015817669343324
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -231584178474632390847141970017375815706539969331281128078915168015817669343324
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 (- (* IRONCLAD::X1+B IRONCLAD::X1+B) IRONCLAD::A IRONCLAD::C))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (INTEGER
;                                -231584178474632390847141970017375815706539969331281128078915168015817669343324
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -463168356949264781694283940034751631413079938662562256157830336031635338686648
;                          -2)
;                         (INTEGER 0 0)
;                         (INTEGER 2
;                          26815615859885194199148049996411692254958731641184786755447122887441538766748476153938746110844209878665674796247790530825760023193962470159365950691684488))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER
;                                -231584178474632390847141970017375815706539969331281128078915168015817669343324
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -463168356949264781694283940034751631413079938662562256157830336031635338686648
;                          -2)
;                         (INTEGER 0 0)
;                         (INTEGER 2
;                          26815615859885194199148049996411692254958731641184786755447122887441538766748476153938746110844209878665674796247790530825760023193962470159365950691684488))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* 3 IRONCLAD::A)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 3
;                             347376267711948586270712955026063723559809953996921692118372752023726504014986))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 3
;                             347376267711948586270712955026063723559809953996921692118372752023726504014986))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* IRONCLAD::E IRONCLAD::E)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 IRONCLAD::D)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             231584178474632390847141970017375815706539969331281128078915168015817669343324))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             231584178474632390847141970017375815706539969331281128078915168015817669343324))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- IRONCLAD::F (* 2 IRONCLAD::D))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 2
;                                     231584178474632390847141970017375815706539969331281128078915168015817669343324)), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -231584178474632390847141970017375815706539969331281128078915168015817669343324
;                         115792089237316195423570985008687907853269984665640564039457584007908834671662)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 2
;                                     231584178474632390847141970017375815706539969331281128078915168015817669343324)), not a (UNSIGNED-BYTE
;                                                                                                                              64).
;       The result is a (VALUES
;                        (INTEGER
;                         -231584178474632390847141970017375815706539969331281128078915168015817669343324
;                         115792089237316195423570985008687907853269984665640564039457584007908834671662)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::D IRONCLAD::X2)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                         115792089237316195423570985008687907853269984665640564039457584007908834671662)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                         115792089237316195423570985008687907853269984665640564039457584007908834671662)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::E (- IRONCLAD::D IRONCLAD::X2))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The second argument is a (INTEGER
;                                 -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671662), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (INTEGER
;                                 -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671662), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 8 IRONCLAD::C)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 8
;                             926336713898529563388567880069503262826159877325124512315660672063270677373296))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 8
;                             926336713898529563388567880069503262826159877325124512315660672063270677373296))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::E (- IRONCLAD::D IRONCLAD::X2)) (* 8 IRONCLAD::C))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244), not a FIXNUM.
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 8
;                                     926336713898529563388567880069503262826159877325124512315660672063270677373296)), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -13407807929942597099574024998205846127479365820592393377723561443720769383375164413683271584985493507212906901386721425290205136109296895751746246023215540
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 8
;                                     926336713898529563388567880069503262826159877325124512315660672063270677373296)), not a (UNSIGNED-BYTE
;                                                                                                                              64).
;       The result is a (VALUES
;                        (INTEGER
;                         -13407807929942597099574024998205846127479365820592393377723561443720769383375164413683271584985493507212906901386721425290205136109296895751746246023215540
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 IRONCLAD::Y1 IRONCLAD::Z1)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -2) (INTEGER 0 0) (INTEGER 2))
;                               &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -2) (INTEGER 0 0) (INTEGER 2))
;                               &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (INTEGER * -2) (INTEGER 0 0) (INTEGER 2)), not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (INTEGER * -2) (INTEGER 0 0) (INTEGER 2)), not a (UNSIGNED-BYTE
;                                                                                     64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-ADD (SECP256K1-POINT SECP256K1-POINT)
;     (* IRONCLAD::Z1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X1 IRONCLAD::Z2Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X2 IRONCLAD::Z1Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1 IRONCLAD::Z2 IRONCLAD::Z2Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y2 IRONCLAD::Z1 IRONCLAD::Z1Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- IRONCLAD::U2 IRONCLAD::U1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                         115792089237316195423570985008687907853269984665640564039457584007908834671662)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                         115792089237316195423570985008687907853269984665640564039457584007908834671662)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 4 IRONCLAD::H IRONCLAD::H)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 4
;                             463168356949264781694283940034751631413079938662562256157830336031635338686648))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 4
;                             463168356949264781694283940034751631413079938662562256157830336031635338686648))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (INTEGER 0 0)
;                                   (INTEGER 4
;                                    463168356949264781694283940034751631413079938662562256157830336031635338686648)), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (INTEGER 0 0)
;                                   (INTEGER 4
;                                    463168356949264781694283940034751631413079938662562256157830336031635338686648)), not a (UNSIGNED-BYTE
;                                                                                                                             64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

;     (* IRONCLAD::H IRONCLAD::I)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::S2 IRONCLAD::S1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                         115792089237316195423570985008687907853269984665640564039457584007908834671662)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                         115792089237316195423570985008687907853269984665640564039457584007908834671662)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 (- IRONCLAD::S2 IRONCLAD::S1))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (INTEGER
;                                -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                                115792089237316195423570985008687907853269984665640564039457584007908834671662), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -231584178474632390847141970017375815706539969331281128078915168015817669343324
;                          -2)
;                         (INTEGER 0 0)
;                         (INTEGER 2
;                          231584178474632390847141970017375815706539969331281128078915168015817669343324))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER
;                                -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                                115792089237316195423570985008687907853269984665640564039457584007908834671662), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -231584178474632390847141970017375815706539969331281128078915168015817669343324
;                          -2)
;                         (INTEGER 0 0)
;                         (INTEGER 2
;                          231584178474632390847141970017375815706539969331281128078915168015817669343324))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* IRONCLAD::U1 IRONCLAD::I)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::R IRONCLAD::R)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::R IRONCLAD::R) IRONCLAD::J (* 2 IRONCLAD::V))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 IRONCLAD::V)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             231584178474632390847141970017375815706539969331281128078915168015817669343324))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             231584178474632390847141970017375815706539969331281128078915168015817669343324))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::R IRONCLAD::R) IRONCLAD::J (* 2 IRONCLAD::V))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244), not a FIXNUM.
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 2
;                                     231584178474632390847141970017375815706539969331281128078915168015817669343324)), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -347376267711948586270712955026063723559809953996921692118372752023726504014986
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 2
;                                     231584178474632390847141970017375815706539969331281128078915168015817669343324)), not a (UNSIGNED-BYTE
;                                                                                                                              64).
;       The result is a (VALUES
;                        (INTEGER
;                         -347376267711948586270712955026063723559809953996921692118372752023726504014986
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::V IRONCLAD::X3)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                         115792089237316195423570985008687907853269984665640564039457584007908834671662)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                         115792089237316195423570985008687907853269984665640564039457584007908834671662)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::R (- IRONCLAD::V IRONCLAD::X3))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The second argument is a (INTEGER
;                                 -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671662), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (INTEGER
;                                 -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671662), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 IRONCLAD::S1 IRONCLAD::J)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             231584178474632390847141970017375815706539969331281128078915168015817669343324))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             231584178474632390847141970017375815706539969331281128078915168015817669343324))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (INTEGER 0 0)
;                                   (INTEGER 2
;                                    231584178474632390847141970017375815706539969331281128078915168015817669343324)), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (INTEGER 0 0)
;                                   (INTEGER 2
;                                    231584178474632390847141970017375815706539969331281128078915168015817669343324)), not a (UNSIGNED-BYTE
;                                                                                                                             64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::R (- IRONCLAD::V IRONCLAD::X3))
;        (* 2 IRONCLAD::S1 IRONCLAD::J))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244), not a FIXNUM.
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER *
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER *
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ IRONCLAD::Z1 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z1+Z2 IRONCLAD::Z1+Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::Z1+Z2 IRONCLAD::Z1+Z2) IRONCLAD::Z1Z1 IRONCLAD::Z2Z2)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -231584178474632390847141970017375815706539969331281128078915168015817669343324
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -231584178474632390847141970017375815706539969331281128078915168015817669343324
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* (- (* IRONCLAD::Z1+Z2 IRONCLAD::Z1+Z2) IRONCLAD::Z1Z1 IRONCLAD::Z2Z2)
;        IRONCLAD::H)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -231584178474632390847141970017375815706539969331281128078915168015817669343324
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -26815615859885194199148049996411692254958731641184786755447122887441538766748476153938746110844209878665674796247790530825760023193962470159365950691684488
;                         1552518092300708935148979488462502555256886017116696611139052038025878194357327919123326904259801146902371181789763820289842428859885596960430872532398902802048848099563624248617810692556287115773373882875915134104881484722589289528)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -231584178474632390847141970017375815706539969331281128078915168015817669343324
;                                13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842244), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -26815615859885194199148049996411692254958731641184786755447122887441538766748476153938746110844209878665674796247790530825760023193962470159365950691684488
;                         1552518092300708935148979488462502555256886017116696611139052038025878194357327919123326904259801146902371181789763820289842428859885596960430872532398902802048848099563624248617810692556287115773373882875915134104881484722589289528)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-POINT-ON-CURVE-P (SECP256K1-POINT)
;     (* IRONCLAD::Y IRONCLAD::Y)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X IRONCLAD::X IRONCLAD::X)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z IRONCLAD::Z IRONCLAD::Z)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z3 IRONCLAD::Z3)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807929942597099574024998205846127479365820592393377723561443720769383374238076969373055422104939332837398123895265412880011596981235079682975345842245)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::+SECP256K1-B+ IRONCLAD::Z6)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 7
;                             810544624661213367964996895060815354972889892659483948276203088055361842701634))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 7
;                             810544624661213367964996895060815354972889892659483948276203088055361842701634))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (+ IRONCLAD::X3 (* IRONCLAD::+SECP256K1-B+ IRONCLAD::Z6))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 7
;                                     810544624661213367964996895060815354972889892659483948276203088055361842701634)), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         926336713898529563388567880069503262826159877325124512315660672063270677373297)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 7
;                                     810544624661213367964996895060815354972889892659483948276203088055361842701634)), not a (UNSIGNED-BYTE
;                                                                                                                              64).
;       The result is a (VALUES
;                        (MOD
;                         926336713898529563388567880069503262826159877325124512315660672063270677373297)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::Y2 IRONCLAD::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                         115792089237316195423570985008687907853269984665640564039457584007908834671662)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089237316195423570985008687907853269984665640564039457584007908834671663), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089237316195423570985008687907853269984665640564039457584007908834671662
;                         115792089237316195423570985008687907853269984665640564039457584007908834671662)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD SIGN-MESSAGE (SECP256K1-PRIVATE-KEY T)
;     (LENGTH IRONCLAD::MESSAGE)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (MIN (OR IRONCLAD::END (LENGTH IRONCLAD::MESSAGE))
;          (/ IRONCLAD::+SECP256K1-BITS+ 8))
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (SUBSEQ (IRONCLAD:EC-ENCODE-POINT IRONCLAD::R) 1
;             (1+ (/ IRONCLAD::+SECP256K1-BITS+ 8)))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (MOD IRONCLAD::R IRONCLAD::+SECP256K1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (SUBSEQ IRONCLAD::MESSAGE IRONCLAD::START IRONCLAD::END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (MOD (* IRONCLAD::INVK (+ IRONCLAD::E (* IRONCLAD::SK IRONCLAD::R)))
;          IRONCLAD::+SECP256K1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (ZEROP IRONCLAD::R)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL 0
;                                         (115792089237316195423570985008687907852837564279074904382605163141518161494337))), not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL 0
;                                         (115792089237316195423570985008687907852837564279074904382605163141518161494337))), not a DOUBLE-FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (ZEROP IRONCLAD::S)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL 0
;                                         (115792089237316195423570985008687907852837564279074904382605163141518161494337))), not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL 0
;                                         (115792089237316195423570985008687907852837564279074904382605163141518161494337))), not a DOUBLE-FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (MIN (OR IRONCLAD::END (LENGTH IRONCLAD::MESSAGE))
;          (/ IRONCLAD::+SECP256K1-BITS+ 8))
; 
; 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.

;     (* IRONCLAD::SK IRONCLAD::R)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a (OR FLOAT
;                                    (RATIONAL 0
;                                              (115792089237316195423570985008687907852837564279074904382605163141518161494337))), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (OR FLOAT
;                                    (RATIONAL 0
;                                              (115792089237316195423570985008687907852837564279074904382605163141518161494337))), not a (UNSIGNED-BYTE
;                                                                                                                                         64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

;     (+ IRONCLAD::E (* IRONCLAD::SK IRONCLAD::R))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.

;     (* IRONCLAD::INVK (+ IRONCLAD::E (* IRONCLAD::SK IRONCLAD::R)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

; in: DEFMETHOD VERIFY-SIGNATURE (SECP256K1-PUBLIC-KEY T T)
;     (LENGTH IRONCLAD::SIGNATURE)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (LENGTH IRONCLAD::MESSAGE)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (MIN (OR IRONCLAD::END (LENGTH IRONCLAD::MESSAGE))
;          (/ IRONCLAD::+SECP256K1-BITS+ 8))
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (SUBSEQ IRONCLAD::MESSAGE IRONCLAD::START IRONCLAD::END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (MOD (* IRONCLAD::E IRONCLAD::W) IRONCLAD::+SECP256K1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (MOD (* IRONCLAD::R IRONCLAD::W) IRONCLAD::+SECP256K1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (SUBSEQ (IRONCLAD:EC-ENCODE-POINT IRONCLAD::RP) 1
;             (1+ (/ IRONCLAD::+SECP256K1-BITS+ 8)))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (MOD IRONCLAD::V IRONCLAD::+SECP256K1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (< IRONCLAD::R IRONCLAD::+SECP256K1-L+)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (< IRONCLAD::S IRONCLAD::+SECP256K1-L+)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (= IRONCLAD::V IRONCLAD::R)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL 0
;                                         (115792089237316195423570985008687907852837564279074904382605163141518161494337))), not a SINGLE-FLOAT.
;   The second argument is a (OR
;                             (RATIONAL *
;                                       (115792089237316195423570985008687907852837564279074904382605163141518161494337))
;                             SINGLE-FLOAT
;                             (DOUBLE-FLOAT *
;                              (1.157920892373162d77))), not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL 0
;                                         (115792089237316195423570985008687907852837564279074904382605163141518161494337))), not a DOUBLE-FLOAT.
;   The second argument is a (OR
;                             (RATIONAL *
;                                       (115792089237316195423570985008687907852837564279074904382605163141518161494337))
;                             SINGLE-FLOAT
;                             (DOUBLE-FLOAT *
;                              (1.157920892373162d77))), not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

;     (MIN (OR IRONCLAD::END (LENGTH IRONCLAD::MESSAGE))
;          (/ IRONCLAD::+SECP256K1-BITS+ 8))
; 
; 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.

;     (* IRONCLAD::E IRONCLAD::W)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

;     (* IRONCLAD::R IRONCLAD::W)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

;     (= IRONCLAD::V IRONCLAD::R)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR FLOAT
;                                   (RATIONAL 0
;                                             (115792089237316195423570985008687907852837564279074904382605163141518161494337))), not a SINGLE-FLOAT.
;       The second argument is a (OR
;                                 (RATIONAL *
;                                           (115792089237316195423570985008687907852837564279074904382605163141518161494337))
;                                 SINGLE-FLOAT
;                                 (DOUBLE-FLOAT * (1.157920892373162d77))), not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR FLOAT
;                                   (RATIONAL 0
;                                             (115792089237316195423570985008687907852837564279074904382605163141518161494337))), not a DOUBLE-FLOAT.
;       The second argument is a (OR
;                                 (RATIONAL *
;                                           (115792089237316195423570985008687907852837564279074904382605163141518161494337))
;                                 SINGLE-FLOAT
;                                 (DOUBLE-FLOAT * (1.157920892373162d77))), not a DOUBLE-FLOAT.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/secp256k1-tmpESC43OCR.fasl
; compilation finished in 0:00:00.111
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/secp256r1.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/public-key/secp256r1.lisp
; in: DEFMETHOD EC-POINT-EQUAL (SECP256R1-POINT SECP256R1-POINT)
;     (* IRONCLAD::Z1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X1 IRONCLAD::Z2Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X2 IRONCLAD::Z1Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::X1 IRONCLAD::Z2Z2) (* IRONCLAD::X2 IRONCLAD::Z1Z1))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1 IRONCLAD::Z2Z2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y2 IRONCLAD::Z1Z1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::Y1 IRONCLAD::Z2Z2 IRONCLAD::Z2)
;        (* IRONCLAD::Y2 IRONCLAD::Z1Z1 IRONCLAD::Z1))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-DOUBLE (SECP256R1-POINT)
;     (* IRONCLAD::X1 IRONCLAD::X1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1 IRONCLAD::Y1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::YY IRONCLAD::YY)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (+ IRONCLAD::X1 IRONCLAD::YY)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (+ IRONCLAD::Y1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X1+YY IRONCLAD::X1+YY)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::X1+YY IRONCLAD::X1+YY) IRONCLAD::XX IRONCLAD::YYYY)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -231584178420712497525394893898815147060172286830580628391067262617734195707900
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -231584178420712497525394893898815147060172286830580628391067262617734195707900
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 (- (* IRONCLAD::X1+YY IRONCLAD::X1+YY) IRONCLAD::XX IRONCLAD::YYYY))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (INTEGER
;                                -231584178420712497525394893898815147060172286830580628391067262617734195707900
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -463168356841424995050789787797630294120344573661161256782134525235468391415800
;                          -2)
;                         (INTEGER 0 0)
;                         (INTEGER 2
;                          26815615847398200002245113415982023367119598712621145051755384179590888202529249817484977881878654977544402909161125413206429311258373043243049391061205000))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER
;                                -231584178420712497525394893898815147060172286830580628391067262617734195707900
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -463168356841424995050789787797630294120344573661161256782134525235468391415800
;                          -2)
;                         (INTEGER 0 0)
;                         (INTEGER 2
;                          26815615847398200002245113415982023367119598712621145051755384179590888202529249817484977881878654977544402909161125413206429311258373043243049391061205000))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* IRONCLAD::ZZ IRONCLAD::ZZ)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::XX (* IRONCLAD::ZZ IRONCLAD::ZZ))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (MOD
;                                 13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500
;                         115792089210356248762697446949407573530086143415290314195533631308867097853950)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                      64).
;       The result is a (VALUES
;                        (INTEGER
;                         -13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500
;                         115792089210356248762697446949407573530086143415290314195533631308867097853950)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 3 (- IRONCLAD::XX (* IRONCLAD::ZZ IRONCLAD::ZZ)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER
;                                -13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500
;                                115792089210356248762697446949407573530086143415290314195533631308867097853950), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER * -3) (INTEGER 0 0)
;                            (INTEGER 3
;                             347376267631068746288092340848222720590258430245870942586600893926601293561850))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500
;                                115792089210356248762697446949407573530086143415290314195533631308867097853950), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER * -3) (INTEGER 0 0)
;                            (INTEGER 3
;                             347376267631068746288092340848222720590258430245870942586600893926601293561850))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* IRONCLAD::M IRONCLAD::M)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 IRONCLAD::S)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             231584178420712497525394893898815147060172286830580628391067262617734195707900))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             231584178420712497525394893898815147060172286830580628391067262617734195707900))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::M IRONCLAD::M) (* 2 IRONCLAD::S))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501), not a FIXNUM.
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 2
;                                     231584178420712497525394893898815147060172286830580628391067262617734195707900)), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -231584178420712497525394893898815147060172286830580628391067262617734195707900
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 2
;                                     231584178420712497525394893898815147060172286830580628391067262617734195707900)), not a (UNSIGNED-BYTE
;                                                                                                                              64).
;       The result is a (VALUES
;                        (INTEGER
;                         -231584178420712497525394893898815147060172286830580628391067262617734195707900
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::S IRONCLAD::U)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                         115792089210356248762697446949407573530086143415290314195533631308867097853950)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                         115792089210356248762697446949407573530086143415290314195533631308867097853950)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::M (- IRONCLAD::S IRONCLAD::U))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (INTEGER
;                                 -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853950), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (INTEGER
;                                 -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853950), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 8 IRONCLAD::YYYY)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 8
;                             926336713682849990101579575595260588240689147322322513564269050470936782831600))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 8
;                             926336713682849990101579575595260588240689147322322513564269050470936782831600))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::M (- IRONCLAD::S IRONCLAD::U)) (* 8 IRONCLAD::YYYY))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500), not a FIXNUM.
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 8
;                                     926336713682849990101579575595260588240689147322322513564269050470936782831600)), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -13407807923699100001122556707991011683559799356310572525877692089795444101265551245456171790929429068347796715168803395750536978142750790671995632313434100
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 8
;                                     926336713682849990101579575595260588240689147322322513564269050470936782831600)), not a (UNSIGNED-BYTE
;                                                                                                                              64).
;       The result is a (VALUES
;                        (INTEGER
;                         -13407807923699100001122556707991011683559799356310572525877692089795444101265551245456171790929429068347796715168803395750536978142750790671995632313434100
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1+Z1 IRONCLAD::Y1+Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::Y1+Z1 IRONCLAD::Y1+Z1) IRONCLAD::YY IRONCLAD::ZZ)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -231584178420712497525394893898815147060172286830580628391067262617734195707900
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -231584178420712497525394893898815147060172286830580628391067262617734195707900
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-ADD (SECP256R1-POINT SECP256R1-POINT)
;     (* IRONCLAD::Z1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X1 IRONCLAD::Z2Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X2 IRONCLAD::Z1Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1 IRONCLAD::Z2 IRONCLAD::Z2Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y2 IRONCLAD::Z1 IRONCLAD::Z1Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- IRONCLAD::U2 IRONCLAD::U1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                         115792089210356248762697446949407573530086143415290314195533631308867097853950)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                         115792089210356248762697446949407573530086143415290314195533631308867097853950)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 4 IRONCLAD::H IRONCLAD::H)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 4
;                             463168356841424995050789787797630294120344573661161256782134525235468391415800))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 4
;                             463168356841424995050789787797630294120344573661161256782134525235468391415800))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (INTEGER 0 0)
;                                   (INTEGER 4
;                                    463168356841424995050789787797630294120344573661161256782134525235468391415800)), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (INTEGER 0 0)
;                                   (INTEGER 4
;                                    463168356841424995050789787797630294120344573661161256782134525235468391415800)), not a (UNSIGNED-BYTE
;                                                                                                                             64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

;     (* IRONCLAD::H IRONCLAD::I)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::S2 IRONCLAD::S1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                         115792089210356248762697446949407573530086143415290314195533631308867097853950)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                         115792089210356248762697446949407573530086143415290314195533631308867097853950)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 (- IRONCLAD::S2 IRONCLAD::S1))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (INTEGER
;                                -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                                115792089210356248762697446949407573530086143415290314195533631308867097853950), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -231584178420712497525394893898815147060172286830580628391067262617734195707900
;                          -2)
;                         (INTEGER 0 0)
;                         (INTEGER 2
;                          231584178420712497525394893898815147060172286830580628391067262617734195707900))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER
;                                -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                                115792089210356248762697446949407573530086143415290314195533631308867097853950), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -231584178420712497525394893898815147060172286830580628391067262617734195707900
;                          -2)
;                         (INTEGER 0 0)
;                         (INTEGER 2
;                          231584178420712497525394893898815147060172286830580628391067262617734195707900))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* IRONCLAD::U1 IRONCLAD::I)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::R IRONCLAD::R)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::R IRONCLAD::R) IRONCLAD::J (* 2 IRONCLAD::V))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 IRONCLAD::V)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             231584178420712497525394893898815147060172286830580628391067262617734195707900))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             231584178420712497525394893898815147060172286830580628391067262617734195707900))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::R IRONCLAD::R) IRONCLAD::J (* 2 IRONCLAD::V))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500), not a FIXNUM.
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 2
;                                     231584178420712497525394893898815147060172286830580628391067262617734195707900)), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -347376267631068746288092340848222720590258430245870942586600893926601293561850
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 2
;                                     231584178420712497525394893898815147060172286830580628391067262617734195707900)), not a (UNSIGNED-BYTE
;                                                                                                                              64).
;       The result is a (VALUES
;                        (INTEGER
;                         -347376267631068746288092340848222720590258430245870942586600893926601293561850
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::V IRONCLAD::X3)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                         115792089210356248762697446949407573530086143415290314195533631308867097853950)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                         115792089210356248762697446949407573530086143415290314195533631308867097853950)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::R (- IRONCLAD::V IRONCLAD::X3))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (INTEGER
;                                 -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853950), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (INTEGER
;                                 -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853950), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 IRONCLAD::S1 IRONCLAD::J)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             231584178420712497525394893898815147060172286830580628391067262617734195707900))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             231584178420712497525394893898815147060172286830580628391067262617734195707900))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (INTEGER 0 0)
;                                   (INTEGER 2
;                                    231584178420712497525394893898815147060172286830580628391067262617734195707900)), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (INTEGER 0 0)
;                                   (INTEGER 2
;                                    231584178420712497525394893898815147060172286830580628391067262617734195707900)), not a (UNSIGNED-BYTE
;                                                                                                                             64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::R (- IRONCLAD::V IRONCLAD::X3))
;        (* 2 IRONCLAD::S1 IRONCLAD::J))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500), not a FIXNUM.
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER *
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER *
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ IRONCLAD::Z1 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z1+Z2 IRONCLAD::Z1+Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::Z1+Z2 IRONCLAD::Z1+Z2) IRONCLAD::Z1Z1 IRONCLAD::Z2Z2)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -231584178420712497525394893898815147060172286830580628391067262617734195707900
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -231584178420712497525394893898815147060172286830580628391067262617734195707900
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* (- (* IRONCLAD::Z1+Z2 IRONCLAD::Z1+Z2) IRONCLAD::Z1Z1 IRONCLAD::Z2Z2)
;        IRONCLAD::H)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -231584178420712497525394893898815147060172286830580628391067262617734195707900
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -26815615847398200002245113415982023367119598712621145051755384179590888202529249817484977881878654977544402909161125413206429311258373043243049391061205000
;                         1552518091216287575509997016045519883874413001817462420952243358319381311981552516218821248992487553429028716151972263135050472406590473520502256999630780789960399351157211211886562356228292661589244886765074003724582584300504875000)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -231584178420712497525394893898815147060172286830580628391067262617734195707900
;                                13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602500), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                     64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -26815615847398200002245113415982023367119598712621145051755384179590888202529249817484977881878654977544402909161125413206429311258373043243049391061205000
;                         1552518091216287575509997016045519883874413001817462420952243358319381311981552516218821248992487553429028716151972263135050472406590473520502256999630780789960399351157211211886562356228292661589244886765074003724582584300504875000)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-POINT-ON-CURVE-P (SECP256R1-POINT)
;     (* IRONCLAD::Y IRONCLAD::Y)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X IRONCLAD::X IRONCLAD::X)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z IRONCLAD::Z)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z4 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (MOD
;                         13407807923699100001122556707991011683559799356310572525877692089795444101264624908742488940939327488772201454580562706603214655629186521621524695530602501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* -3 IRONCLAD::X IRONCLAD::Z4)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -3) (INTEGER 0 0) (INTEGER 3))
;                               &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -3) (INTEGER 0 0) (INTEGER 3))
;                               &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (INTEGER * -3) (INTEGER 0 0) (INTEGER 3)), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (INTEGER * -3) (INTEGER 0 0) (INTEGER 3)), not a (UNSIGNED-BYTE
;                                                                                     64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (+ IRONCLAD::X3 (* -3 IRONCLAD::X IRONCLAD::Z4)
;        (* IRONCLAD::+SECP256R1-B+ IRONCLAD::Z6))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER
;                                     41058363725152142129326129780047268409114441015993725554835256314039467401291
;                                     4754233715294071753536997766098265397605321291568756963789803770565338829955226958282817707719945690448174040500929197932238602174421086657888409559449450)), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER
;                                     41058363725152142129326129780047268409114441015993725554835256314039467401291
;                                     4754233715294071753536997766098265397605321291568756963789803770565338829955226958282817707719945690448174040500929197932238602174421086657888409559449450)), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                          64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- IRONCLAD::Y2 IRONCLAD::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                         115792089210356248762697446949407573530086143415290314195533631308867097853950)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                        64).
;       The second argument is a (MOD
;                                 115792089210356248762697446949407573530086143415290314195533631308867097853951), not a (UNSIGNED-BYTE
;                                                                                                                         64).
;       The result is a (VALUES
;                        (INTEGER
;                         -115792089210356248762697446949407573530086143415290314195533631308867097853950
;                         115792089210356248762697446949407573530086143415290314195533631308867097853950)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD SIGN-MESSAGE (SECP256R1-PRIVATE-KEY T)
;     (LENGTH IRONCLAD::MESSAGE)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (MIN (OR IRONCLAD::END (LENGTH IRONCLAD::MESSAGE))
;          (/ IRONCLAD::+SECP256R1-BITS+ 8))
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (SUBSEQ (IRONCLAD:EC-ENCODE-POINT IRONCLAD::R) 1
;             (1+ (/ IRONCLAD::+SECP256R1-BITS+ 8)))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (MOD IRONCLAD::R IRONCLAD::+SECP256R1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (SUBSEQ IRONCLAD::MESSAGE IRONCLAD::START IRONCLAD::END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (MOD (* IRONCLAD::INVK (+ IRONCLAD::E (* IRONCLAD::SK IRONCLAD::R)))
;          IRONCLAD::+SECP256R1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (ZEROP IRONCLAD::R)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL 0
;                                         (115792089210356248762697446949407573529996955224135760342422259061068512044369))), not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL 0
;                                         (115792089210356248762697446949407573529996955224135760342422259061068512044369))), not a DOUBLE-FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (ZEROP IRONCLAD::S)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL 0
;                                         (115792089210356248762697446949407573529996955224135760342422259061068512044369))), not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL 0
;                                         (115792089210356248762697446949407573529996955224135760342422259061068512044369))), not a DOUBLE-FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (MIN (OR IRONCLAD::END (LENGTH IRONCLAD::MESSAGE))
;          (/ IRONCLAD::+SECP256R1-BITS+ 8))
; 
; 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.

;     (* IRONCLAD::SK IRONCLAD::R)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a (OR FLOAT
;                                    (RATIONAL 0
;                                              (115792089210356248762697446949407573529996955224135760342422259061068512044369))), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (OR FLOAT
;                                    (RATIONAL 0
;                                              (115792089210356248762697446949407573529996955224135760342422259061068512044369))), not a (UNSIGNED-BYTE
;                                                                                                                                         64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

;     (+ IRONCLAD::E (* IRONCLAD::SK IRONCLAD::R))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.

;     (* IRONCLAD::INVK (+ IRONCLAD::E (* IRONCLAD::SK IRONCLAD::R)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

; in: DEFMETHOD VERIFY-SIGNATURE (SECP256R1-PUBLIC-KEY T T)
;     (LENGTH IRONCLAD::SIGNATURE)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (LENGTH IRONCLAD::MESSAGE)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (MIN (OR IRONCLAD::END (LENGTH IRONCLAD::MESSAGE))
;          (/ IRONCLAD::+SECP256R1-BITS+ 8))
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (SUBSEQ IRONCLAD::MESSAGE IRONCLAD::START IRONCLAD::END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (MOD (* IRONCLAD::E IRONCLAD::W) IRONCLAD::+SECP256R1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (MOD (* IRONCLAD::R IRONCLAD::W) IRONCLAD::+SECP256R1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (SUBSEQ (IRONCLAD:EC-ENCODE-POINT IRONCLAD::RP) 1
;             (1+ (/ IRONCLAD::+SECP256R1-BITS+ 8)))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (MOD IRONCLAD::V IRONCLAD::+SECP256R1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (< IRONCLAD::R IRONCLAD::+SECP256R1-L+)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (< IRONCLAD::S IRONCLAD::+SECP256R1-L+)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (= IRONCLAD::V IRONCLAD::R)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL 0
;                                         (115792089210356248762697446949407573529996955224135760342422259061068512044369))), not a SINGLE-FLOAT.
;   The second argument is a (OR
;                             (RATIONAL *
;                                       (115792089210356248762697446949407573529996955224135760342422259061068512044369))
;                             SINGLE-FLOAT
;                             (DOUBLE-FLOAT *
;                              (1.1579208921035625d77))), not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL 0
;                                         (115792089210356248762697446949407573529996955224135760342422259061068512044369))), not a DOUBLE-FLOAT.
;   The second argument is a (OR
;                             (RATIONAL *
;                                       (115792089210356248762697446949407573529996955224135760342422259061068512044369))
;                             SINGLE-FLOAT
;                             (DOUBLE-FLOAT *
;                              (1.1579208921035625d77))), not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

;     (MIN (OR IRONCLAD::END (LENGTH IRONCLAD::MESSAGE))
;          (/ IRONCLAD::+SECP256R1-BITS+ 8))
; 
; 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.

;     (* IRONCLAD::E IRONCLAD::W)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

;     (* IRONCLAD::R IRONCLAD::W)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

;     (= IRONCLAD::V IRONCLAD::R)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR FLOAT
;                                   (RATIONAL 0
;                                             (115792089210356248762697446949407573529996955224135760342422259061068512044369))), not a SINGLE-FLOAT.
;       The second argument is a (OR
;                                 (RATIONAL *
;                                           (115792089210356248762697446949407573529996955224135760342422259061068512044369))
;                                 SINGLE-FLOAT
;                                 (DOUBLE-FLOAT * (1.1579208921035625d77))), not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR FLOAT
;                                   (RATIONAL 0
;                                             (115792089210356248762697446949407573529996955224135760342422259061068512044369))), not a DOUBLE-FLOAT.
;       The second argument is a (OR
;                                 (RATIONAL *
;                                           (115792089210356248762697446949407573529996955224135760342422259061068512044369))
;                                 SINGLE-FLOAT
;                                 (DOUBLE-FLOAT * (1.1579208921035625d77))), not a DOUBLE-FLOAT.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/secp256r1-tmpWCAM54ZJ.fasl
; compilation finished in 0:00:00.134
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/secp384r1.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/public-key/secp384r1.lisp
; in: DEFMETHOD EC-POINT-EQUAL (SECP384R1-POINT SECP384R1-POINT)
;     (* IRONCLAD::Z1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X1 IRONCLAD::Z2Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X2 IRONCLAD::Z1Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::X1 IRONCLAD::Z2Z2) (* IRONCLAD::X2 IRONCLAD::Z1Z1))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1 IRONCLAD::Z2Z2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y2 IRONCLAD::Z1Z1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::Y1 IRONCLAD::Z2Z2 IRONCLAD::Z2)
;        (* IRONCLAD::Y2 IRONCLAD::Z1Z1 IRONCLAD::Z1))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-DOUBLE (SECP384R1-POINT)
;     (* IRONCLAD::X1 IRONCLAD::X1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1 IRONCLAD::Y1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::YY IRONCLAD::YY)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (+ IRONCLAD::X1 IRONCLAD::YY)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (+ IRONCLAD::Y1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X1+YY IRONCLAD::X1+YY)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::X1+YY IRONCLAD::X1+YY) IRONCLAD::XX IRONCLAD::YYYY)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                  64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (INTEGER
;                         -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                  64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (INTEGER
;                         -78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 (- (* IRONCLAD::X1+YY IRONCLAD::X1+YY) IRONCLAD::XX IRONCLAD::YYYY))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (INTEGER
;                                -78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -157608024785577916849116160400574455220318957081861786671793173616982887085987481316189064353035752007446427892449272
;                          -2)
;                         (INTEGER 0 0)
;                         (INTEGER 2
;                          3105036184601417870297958976925005110513772034233393222278104076052101905372700141430024560274693395832057788542144782282353551727589801977734234003608481621184985731633745906459241153960995688116812978434126637816813345998886666248))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER
;                                -78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -157608024785577916849116160400574455220318957081861786671793173616982887085987481316189064353035752007446427892449272
;                          -2)
;                         (INTEGER 0 0)
;                         (INTEGER 2
;                          3105036184601417870297958976925005110513772034233393222278104076052101905372700141430024560274693395832057788542144782282353551727589801977734234003608481621184985731633745906459241153960995688116812978434126637816813345998886666248))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* IRONCLAD::ZZ IRONCLAD::ZZ)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::XX (* IRONCLAD::ZZ IRONCLAD::ZZ))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (MOD
;                                 1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124
;                         39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (MOD
;                                 1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                   64).
;       The result is a (VALUES
;                        (INTEGER
;                         -1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124
;                         39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 3 (- IRONCLAD::XX (* IRONCLAD::ZZ IRONCLAD::ZZ)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER
;                                -1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER * -3) (INTEGER 0 0)
;                            (INTEGER 3
;                             118206018589183437636837120300430841415239217811396340003844880212737165314490610987141798264776814005584820919336954))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER * -3) (INTEGER 0 0)
;                            (INTEGER 3
;                             118206018589183437636837120300430841415239217811396340003844880212737165314490610987141798264776814005584820919336954))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* IRONCLAD::M IRONCLAD::M)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 IRONCLAD::S)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::M IRONCLAD::M) (* 2 IRONCLAD::S))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125), not a FIXNUM.
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 2
;                                     78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636)), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                  64).
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 2
;                                     78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636)), not a (UNSIGNED-BYTE
;                                                                                                                                                                    64).
;       The result is a (VALUES
;                        (INTEGER
;                         -78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::S IRONCLAD::U)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                         39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (INTEGER
;                         -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                         39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::M (- IRONCLAD::S IRONCLAD::U))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (INTEGER
;                                 -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (INTEGER
;                                 -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (INTEGER
;                         -1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 8 IRONCLAD::YYYY)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 8
;                             315216049571155833698232320801148910440637914163723573343586347233965774171974962632378128706071504014892855784898544))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 8
;                             315216049571155833698232320801148910440637914163723573343586347233965774171974962632378128706071504014892855784898544))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::M (- IRONCLAD::S IRONCLAD::U)) (* 8 IRONCLAD::YYYY))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124), not a FIXNUM.
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 8
;                                     315216049571155833698232320801148910440637914163723573343586347233965774171974962632378128706071504014892855784898544)), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                  64).
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 8
;                                     315216049571155833698232320801148910440637914163723573343586347233965774171974962632378128706071504014892855784898544)), not a (UNSIGNED-BYTE
;                                                                                                                                                                     64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1+Z1 IRONCLAD::Y1+Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::Y1+Z1 IRONCLAD::Y1+Z1) IRONCLAD::YY IRONCLAD::ZZ)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                  64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (INTEGER
;                         -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                  64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (INTEGER
;                         -78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-ADD (SECP384R1-POINT SECP384R1-POINT)
;     (* IRONCLAD::Z1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X1 IRONCLAD::Z2Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X2 IRONCLAD::Z1Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1 IRONCLAD::Z2 IRONCLAD::Z2Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y2 IRONCLAD::Z1 IRONCLAD::Z1Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- IRONCLAD::U2 IRONCLAD::U1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                         39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (INTEGER
;                         -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                         39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 4 IRONCLAD::H IRONCLAD::H)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 4
;                             157608024785577916849116160400574455220318957081861786671793173616982887085987481316189064353035752007446427892449272))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 4
;                             157608024785577916849116160400574455220318957081861786671793173616982887085987481316189064353035752007446427892449272))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (INTEGER 0 0)
;                                   (INTEGER 4
;                                    157608024785577916849116160400574455220318957081861786671793173616982887085987481316189064353035752007446427892449272)), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (INTEGER 0 0)
;                                   (INTEGER 4
;                                    157608024785577916849116160400574455220318957081861786671793173616982887085987481316189064353035752007446427892449272)), not a (UNSIGNED-BYTE
;                                                                                                                                                                    64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

;     (* IRONCLAD::H IRONCLAD::I)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::S2 IRONCLAD::S1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                         39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (INTEGER
;                         -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                         39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 (- IRONCLAD::S2 IRONCLAD::S1))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (INTEGER
;                                -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636
;                          -2)
;                         (INTEGER 0 0)
;                         (INTEGER 2
;                          78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER
;                                -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636
;                          -2)
;                         (INTEGER 0 0)
;                         (INTEGER 2
;                          78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* IRONCLAD::U1 IRONCLAD::I)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::R IRONCLAD::R)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::R IRONCLAD::R) IRONCLAD::J (* 2 IRONCLAD::V))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                  64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (INTEGER
;                         -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 IRONCLAD::V)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::R IRONCLAD::R) IRONCLAD::J (* 2 IRONCLAD::V))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124), not a FIXNUM.
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 2
;                                     78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636)), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -118206018589183437636837120300430841415239217811396340003844880212737165314490610987141798264776814005584820919336954)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                  64).
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 2
;                                     78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636)), not a (UNSIGNED-BYTE
;                                                                                                                                                                    64).
;       The result is a (VALUES
;                        (INTEGER
;                         -118206018589183437636837120300430841415239217811396340003844880212737165314490610987141798264776814005584820919336954)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::V IRONCLAD::X3)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                         39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (INTEGER
;                         -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                         39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::R (- IRONCLAD::V IRONCLAD::X3))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (INTEGER
;                                 -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (INTEGER
;                                 -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (INTEGER
;                         -1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 IRONCLAD::S1 IRONCLAD::J)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (INTEGER 0 0)
;                                   (INTEGER 2
;                                    78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636)), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (INTEGER 0 0)
;                                   (INTEGER 2
;                                    78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636)), not a (UNSIGNED-BYTE
;                                                                                                                                                                   64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::R (- IRONCLAD::V IRONCLAD::X3))
;        (* 2 IRONCLAD::S1 IRONCLAD::J))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124), not a FIXNUM.
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER *
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                  64).
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER *
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ IRONCLAD::Z1 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z1+Z2 IRONCLAD::Z1+Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::Z1+Z2 IRONCLAD::Z1+Z2) IRONCLAD::Z1Z1 IRONCLAD::Z2Z2)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                  64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (INTEGER
;                         -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                  64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (INTEGER
;                         -78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* (- (* IRONCLAD::Z1+Z2 IRONCLAD::Z1+Z2) IRONCLAD::Z1Z1 IRONCLAD::Z2Z2)
;        IRONCLAD::H)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -3105036184601417870297958976925005110513772034233393222278104076052101905372700141430024560274693395832057788542144782282353551727589801977734234003608481621184985731633745906459241153960995688116812978434126637816813345998886666248
;                         61172327492847069472032393719205726809135813743440799050195397570919697796090373438193087932951745364335411418754192158027371883482871393221879462331321106336775708560918647649541641604232637072055046695989901089216659016884039006326354228973932344229259162402188271721529352380657325954679977318277520211348882541876885333111266759951749941821432)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -78804012392788958424558080200287227610159478540930893335896586808491443542993740658094532176517876003723213946224636
;                                1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333124), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                  64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (INTEGER
;                         -3105036184601417870297958976925005110513772034233393222278104076052101905372700141430024560274693395832057788542144782282353551727589801977734234003608481621184985731633745906459241153960995688116812978434126637816813345998886666248
;                         61172327492847069472032393719205726809135813743440799050195397570919697796090373438193087932951745364335411418754192158027371883482871393221879462331321106336775708560918647649541641604232637072055046695989901089216659016884039006326354228973932344229259162402188271721529352380657325954679977318277520211348882541876885333111266759951749941821432)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-POINT-ON-CURVE-P (SECP384R1-POINT)
;     (* IRONCLAD::Y IRONCLAD::Y)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X IRONCLAD::X IRONCLAD::X)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z IRONCLAD::Z)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z4 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (MOD
;                         1552518092300708935148979488462502555256886017116696611139052038026050952686350070715012280137346697916028894271072391141176775863794900988867117001804240810592492865816872953229620576980497844058406489217063318908406672999443333125)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* -3 IRONCLAD::X IRONCLAD::Z4)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -3) (INTEGER 0 0) (INTEGER 3))
;                               &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -3) (INTEGER 0 0) (INTEGER 3))
;                               &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (INTEGER * -3) (INTEGER 0 0) (INTEGER 3)), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (INTEGER * -3) (INTEGER 0 0) (INTEGER 3)), not a (UNSIGNED-BYTE
;                                                                                     64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (+ IRONCLAD::X3 (* -3 IRONCLAD::X IRONCLAD::Z4)
;        (* IRONCLAD::+SECP384R1-B+ IRONCLAD::Z6))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER
;                                     27580193559959705877849011840389048093056905856361568521428707301988689241309860865136260764883745107765439761230575
;                                     1086714957547291441539380743186883691325052640168535502985634527585716824737423997330458424652672228621187160777634281319450819776407920055319325979067815022545612052681671576296126271714236782641033750695114220282292143901370722850)), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER
;                                     27580193559959705877849011840389048093056905856361568521428707301988689241309860865136260764883745107765439761230575
;                                     1086714957547291441539380743186883691325052640168535502985634527585716824737423997330458424652672228621187160777634281319450819776407920055319325979067815022545612052681671576296126271714236782641033750695114220282292143901370722850)), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                        64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- IRONCLAD::Y2 IRONCLAD::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                         39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                              64).
;       The second argument is a (MOD
;                                 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319), not a (UNSIGNED-BYTE
;                                                                                                                                                               64).
;       The result is a (VALUES
;                        (INTEGER
;                         -39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318
;                         39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112318)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD SIGN-MESSAGE (SECP384R1-PRIVATE-KEY T)
;     (LENGTH IRONCLAD::MESSAGE)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (MIN (OR IRONCLAD::END (LENGTH IRONCLAD::MESSAGE))
;          (/ IRONCLAD::+SECP384R1-BITS+ 8))
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (SUBSEQ (IRONCLAD:EC-ENCODE-POINT IRONCLAD::R) 1
;             (1+ (/ IRONCLAD::+SECP384R1-BITS+ 8)))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (MOD IRONCLAD::R IRONCLAD::+SECP384R1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (SUBSEQ IRONCLAD::MESSAGE IRONCLAD::START IRONCLAD::END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (MOD (* IRONCLAD::INVK (+ IRONCLAD::E (* IRONCLAD::SK IRONCLAD::R)))
;          IRONCLAD::+SECP384R1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (ZEROP IRONCLAD::R)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL 0
;                                         (39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643))), not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL 0
;                                         (39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643))), not a DOUBLE-FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (ZEROP IRONCLAD::S)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL 0
;                                         (39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643))), not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL 0
;                                         (39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643))), not a DOUBLE-FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (MIN (OR IRONCLAD::END (LENGTH IRONCLAD::MESSAGE))
;          (/ IRONCLAD::+SECP384R1-BITS+ 8))
; 
; 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.

;     (* IRONCLAD::SK IRONCLAD::R)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a (OR FLOAT
;                                    (RATIONAL 0
;                                              (39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643))), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (OR FLOAT
;                                    (RATIONAL 0
;                                              (39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643))), not a (UNSIGNED-BYTE
;                                                                                                                                                                               64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

;     (+ IRONCLAD::E (* IRONCLAD::SK IRONCLAD::R))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.

;     (* IRONCLAD::INVK (+ IRONCLAD::E (* IRONCLAD::SK IRONCLAD::R)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

; in: DEFMETHOD VERIFY-SIGNATURE (SECP384R1-PUBLIC-KEY T T)
;     (LENGTH IRONCLAD::SIGNATURE)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (LENGTH IRONCLAD::MESSAGE)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (MIN (OR IRONCLAD::END (LENGTH IRONCLAD::MESSAGE))
;          (/ IRONCLAD::+SECP384R1-BITS+ 8))
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (SUBSEQ IRONCLAD::MESSAGE IRONCLAD::START IRONCLAD::END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (MOD (* IRONCLAD::E IRONCLAD::W) IRONCLAD::+SECP384R1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (MOD (* IRONCLAD::R IRONCLAD::W) IRONCLAD::+SECP384R1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (SUBSEQ (IRONCLAD:EC-ENCODE-POINT IRONCLAD::RP) 1
;             (1+ (/ IRONCLAD::+SECP384R1-BITS+ 8)))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (MOD IRONCLAD::V IRONCLAD::+SECP384R1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (< IRONCLAD::R IRONCLAD::+SECP384R1-L+)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (< IRONCLAD::S IRONCLAD::+SECP384R1-L+)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (= IRONCLAD::V IRONCLAD::R)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL 0
;                                         (39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643))), not a SINGLE-FLOAT.
;   The second argument is a (OR
;                             (RATIONAL *
;                                       (39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643))
;                             SINGLE-FLOAT
;                             (DOUBLE-FLOAT *
;                              (3.940200619639448d115))), not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT
;                               (RATIONAL 0
;                                         (39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643))), not a DOUBLE-FLOAT.
;   The second argument is a (OR
;                             (RATIONAL *
;                                       (39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643))
;                             SINGLE-FLOAT
;                             (DOUBLE-FLOAT *
;                              (3.940200619639448d115))), not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

;     (MIN (OR IRONCLAD::END (LENGTH IRONCLAD::MESSAGE))
;          (/ IRONCLAD::+SECP384R1-BITS+ 8))
; 
; 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.

;     (* IRONCLAD::E IRONCLAD::W)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

;     (* IRONCLAD::R IRONCLAD::W)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

;     (= IRONCLAD::V IRONCLAD::R)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR FLOAT
;                                   (RATIONAL 0
;                                             (39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643))), not a SINGLE-FLOAT.
;       The second argument is a (OR
;                                 (RATIONAL *
;                                           (39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643))
;                                 SINGLE-FLOAT
;                                 (DOUBLE-FLOAT * (3.940200619639448d115))), not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR FLOAT
;                                   (RATIONAL 0
;                                             (39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643))), not a DOUBLE-FLOAT.
;       The second argument is a (OR
;                                 (RATIONAL *
;                                           (39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643))
;                                 SINGLE-FLOAT
;                                 (DOUBLE-FLOAT * (3.940200619639448d115))), not a DOUBLE-FLOAT.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/secp384r1-tmpVTMW561L.fasl
; compilation finished in 0:00:00.097
; compiling file "/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/secp521r1.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/ironclad-20240503-6da010f/src/public-key/secp521r1.lisp
; in: DEFMETHOD EC-POINT-EQUAL (SECP521R1-POINT SECP521R1-POINT)
;     (* IRONCLAD::Z1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X1 IRONCLAD::Z2Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X2 IRONCLAD::Z1Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::X1 IRONCLAD::Z2Z2) (* IRONCLAD::X2 IRONCLAD::Z1Z1))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1 IRONCLAD::Z2Z2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y2 IRONCLAD::Z1Z1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::Y1 IRONCLAD::Z2Z2 IRONCLAD::Z2)
;        (* IRONCLAD::Y2 IRONCLAD::Z1Z1 IRONCLAD::Z1))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-DOUBLE (SECP521R1-POINT)
;     (* IRONCLAD::X1 IRONCLAD::X1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1 IRONCLAD::Y1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::YY IRONCLAD::YY)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                       64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (+ IRONCLAD::X1 IRONCLAD::YY)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (+ IRONCLAD::Y1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X1+YY IRONCLAD::X1+YY)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                       64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::X1+YY IRONCLAD::X1+YY) IRONCLAD::XX IRONCLAD::YYYY)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                                                                                                    64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                                47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                                47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                                                                                                    64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 (- (* IRONCLAD::X1+YY IRONCLAD::X1+YY) IRONCLAD::XX IRONCLAD::YYYY))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (INTEGER
;                                -13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300
;                                47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -27459190640522438859927603196325572869077741200573221637577853836742172733590624208490238562645818219909185245565923432148487951998866575250296113164460228600
;                          -2)
;                         (INTEGER 0 0)
;                         (INTEGER 2
;                          94250893829069388263158195986839619953910191433570402840572110390025349132714488958921462158410402245441022265850013080700211570312172862173529993715108609666852792026890997824686731717646966455544335553636300229376908671459619712020946539918752105226262272727429889999778597381617749504296368798753798895532245000))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER
;                                -13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300
;                                47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -27459190640522438859927603196325572869077741200573221637577853836742172733590624208490238562645818219909185245565923432148487951998866575250296113164460228600
;                          -2)
;                         (INTEGER 0 0)
;                         (INTEGER 2
;                          94250893829069388263158195986839619953910191433570402840572110390025349132714488958921462158410402245441022265850013080700211570312172862173529993715108609666852792026890997824686731717646966455544335553636300229376908671459619712020946539918752105226262272727429889999778597381617749504296368798753798895532245000))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* IRONCLAD::ZZ IRONCLAD::ZZ)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                       64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::XX (* IRONCLAD::ZZ IRONCLAD::ZZ))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The second argument is a (MOD
;                                 47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500
;                         6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                       64).
;       The second argument is a (MOD
;                                 47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                                                                                                     64).
;       The result is a (VALUES
;                        (INTEGER
;                         -47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500
;                         6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 3 (- IRONCLAD::XX (* IRONCLAD::ZZ IRONCLAD::ZZ)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER
;                                -47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150), not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -3) (INTEGER 0 0) (INTEGER 3))
;                               &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150), not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -3) (INTEGER 0 0) (INTEGER 3))
;                               &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* IRONCLAD::M IRONCLAD::M)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

;     (* 2 IRONCLAD::S)
; 
; 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 (OR (INTEGER 0 0) (INTEGER 2)) &OPTIONAL), not a (VALUES
;                                                                                 FIXNUM
;                                                                                 &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER 0 0) (INTEGER 2)) &OPTIONAL), not a (VALUES
;                                                                                 FIXNUM
;                                                                                 &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::M IRONCLAD::M) (* 2 IRONCLAD::S))
; 
; 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 second argument is a (OR (INTEGER 0 0) (INTEGER 2)), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a (OR (INTEGER 0 0) (INTEGER 2)), not a (UNSIGNED-BYTE
;                                                                       64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- IRONCLAD::S IRONCLAD::U)
; 
; 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 second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::M (- IRONCLAD::S IRONCLAD::U))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a (INTEGER
;                                 -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER
;                                 -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* 8 IRONCLAD::YYYY)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 8
;                             54918381281044877719855206392651145738155482401146443275155707673484345467181248416980477125291636439818370491131846864296975903997733150500592226328920457200))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 8
;                             54918381281044877719855206392651145738155482401146443275155707673484345467181248416980477125291636439818370491131846864296975903997733150500592226328920457200))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::M (- IRONCLAD::S IRONCLAD::U)) (* 8 IRONCLAD::YYYY))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 8
;                                     54918381281044877719855206392651145738155482401146443275155707673484345467181248416980477125291636439818370491131846864296975903997733150500592226328920457200)), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 8
;                                     54918381281044877719855206392651145738155482401146443275155707673484345467181248416980477125291636439818370491131846864296975903997733150500592226328920457200)), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                              64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1+Z1 IRONCLAD::Y1+Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                       64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::Y1+Z1 IRONCLAD::Y1+Z1) IRONCLAD::YY IRONCLAD::ZZ)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                                                                                                    64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                                47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                                47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                                                                                                    64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-ADD (SECP521R1-POINT SECP521R1-POINT)
;     (* IRONCLAD::Z1 IRONCLAD::Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X1 IRONCLAD::Z2Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X2 IRONCLAD::Z1Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y1 IRONCLAD::Z2 IRONCLAD::Z2Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Y2 IRONCLAD::Z1 IRONCLAD::Z1Z1)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- IRONCLAD::U2 IRONCLAD::U1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                         6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                       64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                         6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 4 IRONCLAD::H IRONCLAD::H)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 4
;                             27459190640522438859927603196325572869077741200573221637577853836742172733590624208490238562645818219909185245565923432148487951998866575250296113164460228600))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 4
;                             27459190640522438859927603196325572869077741200573221637577853836742172733590624208490238562645818219909185245565923432148487951998866575250296113164460228600))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (INTEGER 0 0)
;                                   (INTEGER 4
;                                    27459190640522438859927603196325572869077741200573221637577853836742172733590624208490238562645818219909185245565923432148487951998866575250296113164460228600)), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (INTEGER 0 0)
;                                   (INTEGER 4
;                                    27459190640522438859927603196325572869077741200573221637577853836742172733590624208490238562645818219909185245565923432148487951998866575250296113164460228600)), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                             64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

;     (* IRONCLAD::H IRONCLAD::I)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                       64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- IRONCLAD::S2 IRONCLAD::S1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                         6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                       64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                         6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 (- IRONCLAD::S2 IRONCLAD::S1))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (INTEGER
;                                -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300
;                          -2)
;                         (INTEGER 0 0)
;                         (INTEGER 2
;                          13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (INTEGER
;                                -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150), not a FIXNUM.
;       The result is a (VALUES
;                        (OR
;                         (INTEGER
;                          -13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300
;                          -2)
;                         (INTEGER 0 0)
;                         (INTEGER 2
;                          13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (* IRONCLAD::U1 IRONCLAD::I)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                       64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::R IRONCLAD::R)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::R IRONCLAD::R) IRONCLAD::J (* 2 IRONCLAD::V))
; 
; 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 second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 2 IRONCLAD::V)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::R IRONCLAD::R) IRONCLAD::J (* 2 IRONCLAD::V))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150), not a FIXNUM.
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 2
;                                     13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300)), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER 2
;                                     13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300)), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                              64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- IRONCLAD::V IRONCLAD::X3)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                         6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                       64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                         6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::R (- IRONCLAD::V IRONCLAD::X3))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a (INTEGER
;                                 -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER
;                                 -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* 2 IRONCLAD::S1 IRONCLAD::J)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (OR (INTEGER 0 0)
;                            (INTEGER 2
;                             13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (INTEGER 0 0)
;                                   (INTEGER 2
;                                    13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300)), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (INTEGER 0 0)
;                                   (INTEGER 2
;                                    13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300)), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                             64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 64)
;                                                                &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::R (- IRONCLAD::V IRONCLAD::X3))
;        (* 2 IRONCLAD::S1 IRONCLAD::J))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (+ IRONCLAD::Z1 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z1+Z2 IRONCLAD::Z1+Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                       64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- (* IRONCLAD::Z1+Z2 IRONCLAD::Z1+Z2) IRONCLAD::Z1Z1 IRONCLAD::Z2Z2)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                                                                                                    64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                                47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                                47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                                                                                                    64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* (- (* IRONCLAD::Z1+Z2 IRONCLAD::Z1+Z2) IRONCLAD::Z1Z1 IRONCLAD::Z2Z2)
;        IRONCLAD::H)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER
;                                -13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300
;                                47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -94250893829069388263158195986839619953910191433570402840572110390025349132714488958921462158410402245441022265850013080700211570312172862173529993715108609666852792026890997824686731717646966455544335553636300229376908671459619712020946539918752105226262272727429889999778597381617749504296368798753798895532245000
;                         323506657711507029453181996836191423905396619463411038446198094561650090834658129016932671774513214895603258054623797825080015583482483484232107124273991285595557946679886497826749103320711322052528368706114976541287213729802118735079263806492268073748703604020759669694249097481800780470115074570825703566287612472605957916899534347533818426664998835338294071500789521188679927290659570626952894517682587436359707625191202872228989641967995942405768892668191421400875000)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER
;                                -13729595320261219429963801598162786434538870600286610818788926918371086366795312104245119281322909109954592622782961716074243975999433287625148056582230114300
;                                47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122500), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                                                                                                    64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -94250893829069388263158195986839619953910191433570402840572110390025349132714488958921462158410402245441022265850013080700211570312172862173529993715108609666852792026890997824686731717646966455544335553636300229376908671459619712020946539918752105226262272727429889999778597381617749504296368798753798895532245000
;                         323506657711507029453181996836191423905396619463411038446198094561650090834658129016932671774513214895603258054623797825080015583482483484232107124273991285595557946679886497826749103320711322052528368706114976541287213729802118735079263806492268073748703604020759669694249097481800780470115074570825703566287612472605957916899534347533818426664998835338294071500789521188679927290659570626952894517682587436359707625191202872228989641967995942405768892668191421400875000)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD EC-POINT-ON-CURVE-P (SECP521R1-POINT)
;     (* IRONCLAD::Y IRONCLAD::Y)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::X IRONCLAD::X IRONCLAD::X)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z IRONCLAD::Z)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z2 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                       64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* IRONCLAD::Z4 IRONCLAD::Z2)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (MOD
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                       64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (MOD
;                         47125446914534694131579097993419809976955095716785201420286055195012674566357244479460731079205201122720511132925006540350105785156086431086764996857554304833426396013445498912343365858823483227772167776818150114688454335729809856010473269959376052613131136363714944999889298690808874752148184399376899447766122501)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* -3 IRONCLAD::X IRONCLAD::Z4)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -3) (INTEGER 0 0) (INTEGER 3))
;                               &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -3) (INTEGER 0 0) (INTEGER 3))
;                               &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (INTEGER * -3) (INTEGER 0 0) (INTEGER 3)), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (INTEGER * -3) (INTEGER 0 0) (INTEGER 3)), not a (UNSIGNED-BYTE
;                                                                                     64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (+ IRONCLAD::X3 (* -3 IRONCLAD::X IRONCLAD::Z4)
;        (* IRONCLAD::+SECP521R1-B+ IRONCLAD::Z6))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                       64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER
;                                     1093849038073734274511112390766805569936207598951683748994586394495953116150735016013708737573759623248592132296706313309438452531591012912142327488478985984
;                                     7509052317104689266221718773197879358824997841303921778022934628560891681178716185992316901383281939388722899667008339423247323322262598318844851232229404578616146770570011358819916291506176207588497241970009430275979183224789671278182396703835216413712162605475020184622768221244312921726542116999523306208985600)), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (OR (INTEGER 0 0)
;                                    (INTEGER
;                                     1093849038073734274511112390766805569936207598951683748994586394495953116150735016013708737573759623248592132296706313309438452531591012912142327488478985984
;                                     7509052317104689266221718773197879358824997841303921778022934628560891681178716185992316901383281939388722899667008339423247323322262598318844851232229404578616146770570011358819916291506176207588497241970009430275979183224789671278182396703835216413712162605475020184622768221244312921726542116999523306208985600)), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                                                                                                                                                                                         64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (- IRONCLAD::Y2 IRONCLAD::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a FIXNUM.
;       The result is a (VALUES
;                        (INTEGER
;                         -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                         6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (MOD
;                                6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                       64).
;       The second argument is a (MOD
;                                 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151), not a (UNSIGNED-BYTE
;                                                                                                                                                                                                        64).
;       The result is a (VALUES
;                        (INTEGER
;                         -6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150
;                         6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057150)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFMETHOD SIGN-MESSAGE (SECP521R1-PRIVATE-KEY T)
;     (LENGTH IRONCLAD::MESSAGE)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (MIN (OR IRONCLAD::END (LENGTH IRONCLAD::MESSAGE))
;          (CEILING IRONCLAD::+SECP521R1-BITS+ 8))
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (SUBSEQ (IRONCLAD:EC-ENCODE-POINT IRONCLAD::R) 1
;             (1+ (CEILING IRONCLAD::+SECP521R1-BITS+ 8)))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (MOD IRONCLAD::R IRONCLAD::+SECP521R1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (SUBSEQ IRONCLAD::MESSAGE IRONCLAD::START IRONCLAD::END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (MOD (* IRONCLAD::INVK (+ IRONCLAD::E (* IRONCLAD::SK IRONCLAD::R)))
;          IRONCLAD::+SECP521R1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (ZEROP IRONCLAD::R)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT (RATIONAL 0)), not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT (RATIONAL 0)), not a DOUBLE-FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (ZEROP IRONCLAD::S)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT (RATIONAL 0)), not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT (RATIONAL 0)), not a DOUBLE-FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (MIN (OR IRONCLAD::END (LENGTH IRONCLAD::MESSAGE))
;          (CEILING IRONCLAD::+SECP521R1-BITS+ 8))
; 
; 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.

;     (* IRONCLAD::SK IRONCLAD::R)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a (OR FLOAT (RATIONAL 0)), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (OR FLOAT (RATIONAL 0)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

;     (+ IRONCLAD::E (* IRONCLAD::SK IRONCLAD::R))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.

;     (* IRONCLAD::INVK (+ IRONCLAD::E (* IRONCLAD::SK IRONCLAD::R)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

; in: DEFMETHOD VERIFY-SIGNATURE (SECP521R1-PUBLIC-KEY T T)
;     (LENGTH IRONCLAD::SIGNATURE)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (LENGTH IRONCLAD::MESSAGE)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (MIN (OR IRONCLAD::END (LENGTH IRONCLAD::MESSAGE))
;          (CEILING IRONCLAD::+SECP521R1-BITS+ 8))
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (SUBSEQ IRONCLAD::MESSAGE IRONCLAD::START IRONCLAD::END)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (MOD (* IRONCLAD::E IRONCLAD::W) IRONCLAD::+SECP521R1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (MOD (* IRONCLAD::R IRONCLAD::W) IRONCLAD::+SECP521R1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (SUBSEQ (IRONCLAD:EC-ENCODE-POINT IRONCLAD::RP) 1
;             (1+ (CEILING IRONCLAD::+SECP521R1-BITS+ 8)))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (MOD IRONCLAD::V IRONCLAD::+SECP521R1-L+)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (< IRONCLAD::R IRONCLAD::+SECP521R1-L+)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (< IRONCLAD::S IRONCLAD::+SECP521R1-L+)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (= IRONCLAD::V IRONCLAD::R)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT (RATIONAL 0)), not a SINGLE-FLOAT.
;   The second argument is a (OR
;                             (RATIONAL *
;                                       (6864797660130609714981900799081393217269435300143305409394463459185543183397655394245057746333217197532963996371363321113864768612440380340372808892707005449))
;                             SINGLE-FLOAT
;                             (DOUBLE-FLOAT *
;                              (6.86479766013061d156))), not a RATIONAL.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT (RATIONAL 0)), not a DOUBLE-FLOAT.
;   The second argument is a (OR
;                             (RATIONAL *
;                                       (6864797660130609714981900799081393217269435300143305409394463459185543183397655394245057746333217197532963996371363321113864768612440380340372808892707005449))
;                             SINGLE-FLOAT
;                             (DOUBLE-FLOAT *
;                              (6.86479766013061d156))), not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

;     (MIN (OR IRONCLAD::END (LENGTH IRONCLAD::MESSAGE))
;          (CEILING IRONCLAD::+SECP521R1-BITS+ 8))
; 
; 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.

;     (* IRONCLAD::E IRONCLAD::W)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

;     (* IRONCLAD::R IRONCLAD::W)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

;     (= IRONCLAD::V IRONCLAD::R)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR FLOAT (RATIONAL 0)), not a SINGLE-FLOAT.
;       The second argument is a (OR
;                                 (RATIONAL *
;                                           (6864797660130609714981900799081393217269435300143305409394463459185543183397655394245057746333217197532963996371363321113864768612440380340372808892707005449))
;                                 SINGLE-FLOAT
;                                 (DOUBLE-FLOAT * (6.86479766013061d156))), not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR FLOAT (RATIONAL 0)), not a DOUBLE-FLOAT.
;       The second argument is a (OR
;                                 (RATIONAL *
;                                           (6864797660130609714981900799081393217269435300143305409394463459185543183397655394245057746333217197532963996371363321113864768612440380340372808892707005449))
;                                 SINGLE-FLOAT
;                                 (DOUBLE-FLOAT * (6.86479766013061d156))), not a DOUBLE-FLOAT.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/ironclad-20240503-6da010f/src/public-key/secp521r1-tmpUNNGT9CF.fasl
; compilation finished in 0:00:00.114
; compiling file "/workspace/ocicl/jose-20250217-345d8cf/errors.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/jose-20250217-345d8cf/errors-tmp4L3W83SU.fasl
; compilation finished in 0:00:00.006
; compiling file "/workspace/ocicl/cl-base64-20240503-80496b7/package.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/cl-base64-20240503-80496b7/package-tmpGE7QNNEE.fasl
; compilation finished in 0:00:00.008
; compiling file "/workspace/ocicl/cl-base64-20240503-80496b7/encode.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/cl-base64-20240503-80496b7/encode.lisp
; in: DEFUN ROUND-NEXT-MULTIPLE
;     (MOD CL-BASE64::X CL-BASE64::N)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (+ CL-BASE64::X (THE FIXNUM (- CL-BASE64::N CL-BASE64::REMAINDER)))
; 
; 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.
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES FIXNUM &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; in: DEF-*-TO-BASE64-* :STRING
;     (CL-BASE64::DEF-*-TO-BASE64-* :STRING :STRING)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> LET LET* LABELS DO BLOCK LET TAGBODY RETURN-FROM PROGN COND IF 
; --> CL-BASE64::OUTPUT-GROUP THE + THE ASH CHAR-CODE THE CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> LET LET* LABELS DO BLOCK LET TAGBODY RETURN-FROM PROGN COND IF IF 
; --> CL-BASE64::OUTPUT-GROUP THE ASH CHAR-CODE THE CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> LET LET* LABELS DO BLOCK LET TAGBODY TAGBODY CL-BASE64::OUTPUT-GROUP THE 
; --> + 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (CL-BASE64::DEF-*-TO-BASE64-* :STRING :STREAM)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> LET LET* LABELS DO BLOCK LET TAGBODY RETURN-FROM PROGN COND IF 
; --> CL-BASE64::OUTPUT-GROUP THE + THE ASH CHAR-CODE THE CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> LET LET* LABELS DO BLOCK LET TAGBODY RETURN-FROM PROGN COND IF IF 
; --> CL-BASE64::OUTPUT-GROUP THE ASH CHAR-CODE THE CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> LET LET* LABELS DO BLOCK LET TAGBODY TAGBODY CL-BASE64::OUTPUT-GROUP THE 
; --> + 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; in: DEF-*-TO-BASE64-* :USB8-ARRAY
;     (CL-BASE64::DEF-*-TO-BASE64-* :USB8-ARRAY :STRING)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> LET LET* LABELS DO BLOCK LET TAGBODY TAGBODY CL-BASE64::OUTPUT-GROUP THE 
; --> + 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> LET LET* LABELS DO BLOCK LET TAGBODY RETURN-FROM PROGN COND IF 
; --> CL-BASE64::OUTPUT-GROUP THE + THE ASH THE AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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.

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> LET LET* LABELS DO BLOCK LET TAGBODY RETURN-FROM PROGN COND IF IF 
; --> CL-BASE64::OUTPUT-GROUP THE ASH THE AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (CL-BASE64::DEF-*-TO-BASE64-* :USB8-ARRAY :STREAM)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> LET LET* LABELS DO BLOCK LET TAGBODY TAGBODY CL-BASE64::OUTPUT-GROUP THE 
; --> + 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> LET LET* LABELS DO BLOCK LET TAGBODY RETURN-FROM PROGN COND IF 
; --> CL-BASE64::OUTPUT-GROUP THE + THE ASH THE AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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.

; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> LET LET* LABELS DO BLOCK LET TAGBODY RETURN-FROM PROGN COND IF IF 
; --> CL-BASE64::OUTPUT-GROUP THE ASH THE AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; in: DEFUN INTEGER-TO-BASE64-STRING
;     (MOD CL-BASE64::PADDED-BITS 24)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (ZEROP CL-BASE64::REMAINDER-PADDING)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT (RATIONAL 0 (24))), not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT (RATIONAL 0 (24))), not a DOUBLE-FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (/ CL-BASE64::PADDING-BITS 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR FLOAT (RATIONAL 0 24)), not a INTEGER.
; 
; note: unable to
;   convert x/2^k to shift
; due to type uncertainty:
;   The first argument is a (OR FLOAT (RATIONAL 0 24)), not a INTEGER.

;     (/ (+ CL-BASE64::PADDED-BITS CL-BASE64::PADDING-BITS) 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert x/2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (/ CL-BASE64::PADDING-BITS 3)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (RATIONAL 0 24), not a INTEGER.
; 
; note: unable to
;   convert x/2^k to shift
; due to type uncertainty:
;   The first argument is a (RATIONAL 0 24), not a INTEGER.

;     (INTEGER-LENGTH CL-BASE64::INPUT)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (- 24 CL-BASE64::REMAINDER-PADDING)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (OR FLOAT (RATIONAL 0 (24))), not a FIXNUM.
;       The result is a (VALUES (OR FLOAT (RATIONAL (0) 24)) &OPTIONAL), not a (VALUES
;                                                                               FIXNUM
;                                                                               &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (OR FLOAT (RATIONAL 0 (24))), not a (UNSIGNED-BYTE
;                                                                     64).
;       The result is a (VALUES (OR FLOAT (RATIONAL (0) 24)) &OPTIONAL), not a (VALUES
;                                                                               (UNSIGNED-BYTE
;                                                                                64)
;                                                                               &OPTIONAL).
;       etc.

;     (+ CL-BASE64::PADDED-BITS CL-BASE64::PADDING-BITS)
; 
; 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 (RATIONAL 0 24), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a (RATIONAL 0 24), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64)
;                                                              &OPTIONAL).
;       etc.

;     (* CL-BASE64::COLUMNS (TRUNCATE CL-BASE64::PADDED-LENGTH CL-BASE64::COLUMNS))
; 
; note: forced to do */SIGNED=>INTEGER (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The result is a (VALUES
;                        (INTEGER -21267647932558653961849226946058125312
;                         21267647932558653957237540927630737409)
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES
;                        (INTEGER -21267647932558653961849226946058125312
;                         21267647932558653957237540927630737409)
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- CL-BASE64::PADDED-LENGTH
;        (* CL-BASE64::COLUMNS
;           (TRUNCATE CL-BASE64::PADDED-LENGTH CL-BASE64::COLUMNS)))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (INTEGER -21267647932558653961849226946058125312
;                                 21267647932558653957237540927630737409), not a FIXNUM.
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -21267647932558653961849226946058125312
;                                 21267647932558653957237540927630737409), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES FIXNUM &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

;     (ASH CL-BASE64::INPUT (/ CL-BASE64::PADDING-BITS 3))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline ASH (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (LOGAND CL-BASE64::INT 63)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; in: DEFUN INTEGER-TO-BASE64-STREAM
;     (MOD CL-BASE64::PADDED-BITS 24)
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (ZEROP CL-BASE64::REMAINDER-PADDING)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT (RATIONAL 0 (24))), not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a (OR FLOAT (RATIONAL 0 (24))), not a DOUBLE-FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (/ CL-BASE64::PADDING-BITS 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR FLOAT (RATIONAL 0 24)), not a INTEGER.
;   The result is a (VALUES (OR FLOAT (RATIONAL 0 4)) &OPTIONAL), not a (VALUES
;                                                                        INTEGER
;                                                                        &REST T).
; 
; note: unable to
;   convert x/2^k to shift
; due to type uncertainty:
;   The first argument is a (OR FLOAT (RATIONAL 0 24)), not a INTEGER.

;     (/ (+ CL-BASE64::PADDED-BITS CL-BASE64::PADDING-BITS) 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   convert x/2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (/ CL-BASE64::PADDING-BITS 3)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (RATIONAL 0 24), not a INTEGER.
; 
; note: unable to
;   convert x/2^k to shift
; due to type uncertainty:
;   The first argument is a (RATIONAL 0 24), not a INTEGER.

;     (INTEGER-LENGTH CL-BASE64::INPUT)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (- 24 CL-BASE64::REMAINDER-PADDING)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (OR FLOAT (RATIONAL 0 (24))), not a FIXNUM.
;       The result is a (VALUES (OR FLOAT (RATIONAL (0) 24)) &OPTIONAL), not a (VALUES
;                                                                               FIXNUM
;                                                                               &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (OR FLOAT (RATIONAL 0 (24))), not a (UNSIGNED-BYTE
;                                                                     64).
;       The result is a (VALUES (OR FLOAT (RATIONAL (0) 24)) &OPTIONAL), not a (VALUES
;                                                                               (UNSIGNED-BYTE
;                                                                                64)
;                                                                               &OPTIONAL).
;       etc.

;     (+ CL-BASE64::PADDED-BITS CL-BASE64::PADDING-BITS)
; 
; 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 (OR FLOAT (RATIONAL 0 24)), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a (OR FLOAT (RATIONAL 0 24)), not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                              &OPTIONAL).
;       etc.

;     (- CL-BASE64::STRLEN CL-BASE64::PADDING-CHARS)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (OR FLOAT (RATIONAL 0 4)), not a FIXNUM.
;       The result is a (VALUES
;                        (OR FLOAT
;                            (RATIONAL -4611686018427387908 4611686018427387903))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The second argument is a (OR FLOAT (RATIONAL 0 4)), not a (UNSIGNED-BYTE
;                                                                  64).
;       The result is a (VALUES
;                        (OR FLOAT
;                            (RATIONAL -4611686018427387908 4611686018427387903))
;                        &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (1- CL-BASE64::NONPAD-CHARS)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (OR FLOAT
;                                   (RATIONAL -4611686018427387908
;                                             4611686018427387903)), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR FLOAT
;                                   (RATIONAL -4611686018427387908
;                                             4611686018427387903)), not a FIXNUM.
;       etc.

;     (ASH CL-BASE64::INPUT (/ CL-BASE64::PADDING-BITS 3))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline ASH (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

;     (LOGAND CL-BASE64::INT 63)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/cl-base64-20240503-80496b7/encode-tmp9B0UZGT4.fasl
; compilation finished in 0:00:00.111
; compiling file "/workspace/ocicl/cl-base64-20240503-80496b7/decode.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/cl-base64-20240503-80496b7/decode.lisp
; in: DEF-BASE64-STRING-TO-* :STRING
;     (CL-BASE64::DEF-BASE64-STRING-TO-* :STRING)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> LET LET LOOP BLOCK LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> SB-KERNEL:%DATA-VECTOR-AND-INDEX/KNOWN 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; in: DEF-BASE64-STRING-TO-* :STREAM
;     (CL-BASE64::DEF-BASE64-STRING-TO-* :STREAM)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> LET LET LOOP BLOCK LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> SB-KERNEL:%DATA-VECTOR-AND-INDEX/KNOWN 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; in: DEF-BASE64-STRING-TO-* :USB8-ARRAY
;     (CL-BASE64::DEF-BASE64-STRING-TO-* :USB8-ARRAY)
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK 
; --> LET LET LOOP BLOCK LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> SB-KERNEL:%DATA-VECTOR-AND-INDEX/KNOWN 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; in: DEFUN BASE64-STRING-TO-INTEGER
;     (LOOP CL-BASE64::FOR CHAR CL-BASE64::OF-TYPE CHARACTER CL-BASE64::ACROSS STRING
;           CL-BASE64::FOR CL-BASE64::SVALUE CL-BASE64::OF-TYPE FIXNUM = ...)
; --> LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> SB-KERNEL:%DATA-VECTOR-AND-INDEX/KNOWN 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

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

;     (+ CL-BASE64::SVALUE (ASH CL-BASE64::VALUE 6))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (OR (INTEGER * -64) (INTEGER 0 0) (INTEGER 64)), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (OR (INTEGER * -64) (INTEGER 0 0) (INTEGER 64)), not a (UNSIGNED-BYTE
;                                                                                        64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.

; in: DEFUN BASE64-STREAM-TO-INTEGER
;     (ASH CL-BASE64::VALUE 6)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -64) (INTEGER 0 0) (INTEGER 64))
;                               &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -64) (INTEGER 0 0) (INTEGER 64))
;                               &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (+ CL-BASE64::SVALUE (ASH CL-BASE64::VALUE 6))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (OR (INTEGER * -64) (INTEGER 0 0) (INTEGER 64)), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
;                                                                 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (OR (INTEGER * -64) (INTEGER 0 0) (INTEGER 64)), not a (UNSIGNED-BYTE
;                                                                                        64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (UNSIGNED-BYTE 64)
;                                                          &OPTIONAL).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/cl-base64-20240503-80496b7/decode-tmpAJ5U325P.fasl
; compilation finished in 0:00:00.150
; compiling file "/workspace/ocicl/trivial-utf-8-20240503-ba9b4ff/trivial-utf-8.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/trivial-utf-8-20240503-ba9b4ff/trivial-utf-8.lisp
; in: DEFUN UTF-8-BYTES-TO-STRING
;     (COERCE TRIVIAL-UTF-8::BYTES-IN '(SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (AND VECTOR
;                                 (NOT
;                                  (SIMPLE-ARRAY (UNSIGNED-BYTE 8)))), not a (OR
;                                                                             NULL
;                                                                             (SIMPLE-ARRAY
;                                                                              *
;                                                                              (*))).


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/trivial-utf-8-20240503-ba9b4ff/trivial-utf-8-tmpAOF1CYAS.fasl
; compilation finished in 0:00:00.096
; compiling file "/workspace/ocicl/jose-20250217-345d8cf/base64.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/jose-20250217-345d8cf/base64-tmpIXCQTSHA.fasl
; compilation finished in 0:00:00.014
; compiling file "/workspace/ocicl/cl-json-20240907-994dd38/src/package.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/cl-json-20240907-994dd38/src/package-tmp5E6VIEMS.fasl
; compilation finished in 0:00:00.002
; compiling file "/workspace/ocicl/cl-json-20240907-994dd38/src/common.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/cl-json-20240907-994dd38/src/common-tmpI0PODGVV.fasl
; compilation finished in 0:00:00.032
; compiling file "/workspace/ocicl/cl-json-20240907-994dd38/src/objects.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/cl-json-20240907-994dd38/src/objects-tmp1Z95I17K.fasl
; compilation finished in 0:00:00.090
; compiling file "/workspace/ocicl/cl-json-20240907-994dd38/src/camel-case.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/cl-json-20240907-994dd38/src/camel-case-tmpCFVK1AC1.fasl
; compilation finished in 0:00:00.064
; compiling file "/workspace/ocicl/cl-json-20240907-994dd38/src/decoder.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/cl-json-20240907-994dd38/src/decoder-tmpHHRR8E8N.fasl
; compilation finished in 0:00:00.154
; compiling file "/workspace/ocicl/cl-json-20240907-994dd38/src/encoder.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/cl-json-20240907-994dd38/src/encoder-tmpWWJ02E3I.fasl
; compilation finished in 0:00:00.110
; compiling file "/workspace/ocicl/cl-json-20240907-994dd38/src/utils.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/cl-json-20240907-994dd38/src/utils-tmpONTOHUJ2.fasl
; compilation finished in 0:00:00.018
; compiling file "/workspace/ocicl/cl-json-20240907-994dd38/src/json-rpc.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/cl-json-20240907-994dd38/src/json-rpc-tmpQT9APWMH.fasl
; compilation finished in 0:00:00.072
; compiling file "/workspace/ocicl/split-sequence-2.0.1/package.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/split-sequence-2.0.1/package-tmp6LYQXY0L.fasl
; compilation finished in 0:00:00.001
; compiling file "/workspace/ocicl/split-sequence-2.0.1/vector.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/split-sequence-2.0.1/vector-tmpNKVDR0J1.fasl
; compilation finished in 0:00:00.067
; compiling file "/workspace/ocicl/split-sequence-2.0.1/list.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/split-sequence-2.0.1/list-tmp6F83SDCV.fasl
; compilation finished in 0:00:00.126
; compiling file "/workspace/ocicl/split-sequence-2.0.1/extended-sequence.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/split-sequence-2.0.1/extended-sequence-tmpEJNPPMJY.fasl
; compilation finished in 0:00:00.077
; compiling file "/workspace/ocicl/split-sequence-2.0.1/api.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/split-sequence-2.0.1/api-tmp31RWPSX2.fasl
; compilation finished in 0:00:00.313
; compiling file "/workspace/ocicl/split-sequence-2.0.1/documentation.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/split-sequence-2.0.1/documentation-tmp1HKLMSTH.fasl
; compilation finished in 0:00:00.002
; compiling file "/workspace/ocicl/assoc-utils-20241010-b14ab68/src/assoc-utils.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/assoc-utils-20241010-b14ab68/src/assoc-utils-tmpEWG5XJ53.fasl
; compilation finished in 0:00:00.044
; compiling file "/workspace/ocicl/jose-20250217-345d8cf/jws.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/jose-20250217-345d8cf/jws-tmpXHL60MUV.fasl
; compilation finished in 0:00:00.106
; compiling file "/workspace/ocicl/jose-20250217-345d8cf/jwt.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/jose-20250217-345d8cf/jwt-tmpB7NPDQCW.fasl
; compilation finished in 0:00:00.028
; compiling file "/workspace/ocicl/jose-20250217-345d8cf/main.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/jose-20250217-345d8cf/main-tmpGZ70QILE.fasl
; compilation finished in 0:00:00.004
; compiling file "/workspace/ocicl/closer-mop-20260329-04db182/closer-mop-packages.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/closer-mop-20260329-04db182/closer-mop-packages-tmpKYD38Q95.fasl
; compilation finished in 0:00:00.118
; compiling file "/workspace/ocicl/closer-mop-20260329-04db182/closer-mop-shared.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/closer-mop-20260329-04db182/closer-mop-shared.lisp
; in: DEFUN GET-EMF
;     (SUBSEQ CLOSER-MOP::ARGS 0 CLOSER-MOP::NOF-REQUIRED-ARGS)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; in: DEFUN ONLY-STANDARD-METHODS
;     (TYPEP CLOSER-MOP::GF SB-MOP:SPECIALIZER)
; 
; note: unable to optimize because: can't open-code test of non-constant type

;     (EQL (SB-MOP:EQL-SPECIALIZER-OBJECT SB-MOP:SPECIALIZER) CLOSER-MOP::GF)
; 
; 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 SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       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.
;       etc.

; in: DEFUN METHODS-ALL-THE-SAME-SPECIALIZERS
;     (EQL (SB-MOP:EQL-SPECIALIZER-OBJECT CLOSER-MOP::SPEC1)
;          (SB-MOP:EQL-SPECIALIZER-OBJECT CLOSER-MOP::SPEC2))
; 
; 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 SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       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.
;       etc.

; in: DEFUN COMPUTE-DISCRIMINATOR
;     (FUNCALL CLOSER-MOP::COMPUTE-NATIVE-DISCRIMINATOR)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   COMPUTE-NATIVE-DISCRIMINATOR is not known to be a function

;     (TYPEP CLOSER-MOP::ARG CLOSER-MOP::SPEC)
; 
; note: unable to optimize because: can't open-code test of non-constant type

;     (FUNCALL CLOSER-MOP::COMPUTE-NATIVE-DISCRIMINATOR)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; because:
;   COMPUTE-NATIVE-DISCRIMINATOR is not known to be a function

;     (EQL CLOSER-MOP::ARG (SB-MOP:EQL-SPECIALIZER-OBJECT CLOSER-MOP::SPEC))
; 
; 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 SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       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.
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/closer-mop-20260329-04db182/closer-mop-shared-tmpV4YQ0HKA.fasl
; compilation finished in 0:00:00.100
; compiling file "/workspace/ocicl/closer-mop-20260329-04db182/closer-sbcl.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/closer-mop-20260329-04db182/closer-sbcl-tmpJXWE1HN2.fasl
; compilation finished in 0:00:00.001
; compiling file "/workspace/ocicl/trivial-gray-streams-20240503-a7ead68/package.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/trivial-gray-streams-20240503-a7ead68/package-tmpMNC5LX5B.fasl
; compilation finished in 0:00:00.004
; compiling file "/workspace/ocicl/trivial-gray-streams-20240503-a7ead68/streams.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/trivial-gray-streams-20240503-a7ead68/streams-tmp4RNSVVC1.fasl
; compilation finished in 0:00:00.025
; compiling file "/workspace/ocicl/flexi-streams-20240503-4951d57/packages.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/flexi-streams-20240503-4951d57/packages-tmpN626KU7B.fasl
; compilation finished in 0:00:00.002
; compiling file "/workspace/ocicl/flexi-streams-20240503-4951d57/mapping.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/flexi-streams-20240503-4951d57/mapping-tmpOO0K1B0C.fasl
; compilation finished in 0:00:00.009
; compiling file "/workspace/ocicl/flexi-streams-20240503-4951d57/ascii.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/flexi-streams-20240503-4951d57/ascii-tmpVFL7JAFK.fasl
; compilation finished in 0:00:00.001
; compiling file "/workspace/ocicl/flexi-streams-20240503-4951d57/koi8-r.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/flexi-streams-20240503-4951d57/koi8-r-tmpU45RTF.fasl
; compilation finished in 0:00:00.002
; compiling file "/workspace/ocicl/flexi-streams-20240503-4951d57/mac.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/flexi-streams-20240503-4951d57/mac-tmpZTS6G7ND.fasl
; compilation finished in 0:00:00.001
; compiling file "/workspace/ocicl/flexi-streams-20240503-4951d57/iso-8859.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/flexi-streams-20240503-4951d57/iso-8859-tmp5TNBATEG.fasl
; compilation finished in 0:00:00.050
; compiling file "/workspace/ocicl/flexi-streams-20240503-4951d57/enc-cn-tbl.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/flexi-streams-20240503-4951d57/enc-cn-tbl-tmpJL6JXW7Z.fasl
; compilation finished in 0:00:00.121
; compiling file "/workspace/ocicl/flexi-streams-20240503-4951d57/code-pages.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/flexi-streams-20240503-4951d57/code-pages-tmp5PQ00DH7.fasl
; compilation finished in 0:00:00.020
; compiling file "/workspace/ocicl/flexi-streams-20240503-4951d57/specials.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/flexi-streams-20240503-4951d57/specials-tmp5R1KP4O2.fasl
; compilation finished in 0:00:00.011
; compiling file "/workspace/ocicl/flexi-streams-20240503-4951d57/util.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/flexi-streams-20240503-4951d57/util.lisp
; in: DEFUN MAKE-OCTET-BUFFER
;     (MAKE-ARRAY FLEXI-STREAMS::SIZE :ELEMENT-TYPE 'FLEXI-STREAMS:OCTET)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

; in: DEFUN GET-MULTIBYTE-MAPPER
;     (AREF FLEXI-STREAMS::TABLE FLEXI-STREAMS::M 0)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.

;     (AREF FLEXI-STREAMS::TABLE FLEXI-STREAMS::M 1)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/flexi-streams-20240503-4951d57/util-tmpXQDKKJYI.fasl
; compilation finished in 0:00:00.033
; compiling file "/workspace/ocicl/flexi-streams-20240503-4951d57/conditions.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/flexi-streams-20240503-4951d57/conditions-tmpGJ3P31TF.fasl
; compilation finished in 0:00:00.010
; compiling file "/workspace/ocicl/flexi-streams-20240503-4951d57/external-format.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/flexi-streams-20240503-4951d57/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 SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       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.
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/flexi-streams-20240503-4951d57/external-format-tmpT2P2LFJI.fasl
; compilation finished in 0:00:00.140
; compiling file "/workspace/ocicl/flexi-streams-20240503-4951d57/length.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/flexi-streams-20240503-4951d57/length.lisp
; in: DEFMETHOD ENCODING-FACTOR (FLEXI-CRLF-MIXIN)
;     (* 1.02d0 (CALL-NEXT-METHOD))
; 
; note: forced to do GENERIC-* (cost 30)
;       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 DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT))
;                               &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       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 DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT))
;                               &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT)
;                                                         &OPTIONAL).

; 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

; 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

; 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
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to open code because: The operands might not be the same type.

; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-UTF-8-FORMAT T T T)
;     (AREF SEQUENCE FLEXI-STREAMS::I)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-UTF-8-FORMAT T T T)
;     (AREF SEQUENCE FLEXI-STREAMS::I)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; 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

; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-UTF-16-LE-FORMAT T T T)
;     (AREF SEQUENCE (1+ FLEXI-STREAMS::I))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-UTF-16-BE-FORMAT T T T)
;     (AREF SEQUENCE FLEXI-STREAMS::I)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in:
;      DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-UTF-16-LE-FORMAT T T T)
;     (AREF SEQUENCE (1+ FLEXI-STREAMS::I))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (AREF SEQUENCE FLEXI-STREAMS::I)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in:
;      DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-UTF-16-BE-FORMAT T T T)
;     (AREF SEQUENCE FLEXI-STREAMS::I)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (AREF SEQUENCE (1+ FLEXI-STREAMS::I))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-GBK-FORMAT T T T)
;     (AREF SEQUENCE FLEXI-STREAMS::I)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in: DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-GBK-FORMAT T T T)
;     (AREF SEQUENCE FLEXI-STREAMS::I)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; in:
;      DEFMETHOD COMPUTE-NUMBER-OF-CHARS :BEFORE (FLEXI-UTF-32-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

; in:
;      DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-UTF-32-LE-FORMAT T T T)
;     (AREF SEQUENCE FLEXI-STREAMS::J)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (= FLEXI-STREAMS:OCTET (AREF SEQUENCE FLEXI-STREAMS::J))
; 
; note: unable to open code because: The operands might not be the same type.

;     (DECF LENGTH)
; --> SB-IMPL::XSUBTRACT BLOCK 
; ==>
;   (- SB-IMPL::B SB-IMPL::A)
; 
; 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
;                                                                                  &OPTIONAL).
;       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
;                                                                                  &OPTIONAL).
;       etc.

; in:
;      DEFMETHOD COMPUTE-NUMBER-OF-CHARS (FLEXI-CRLF-UTF-32-BE-FORMAT T T T)
;     (AREF SEQUENCE FLEXI-STREAMS::J)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (= FLEXI-STREAMS:OCTET (AREF SEQUENCE FLEXI-STREAMS::J))
; 
; note: unable to open code because: The operands might not be the same type.

;     (DECF LENGTH)
; --> SB-IMPL::XSUBTRACT BLOCK 
; ==>
;   (- SB-IMPL::B SB-IMPL::A)
; 
; 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
;                                                                                  &OPTIONAL).
;       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
;                                                                                  &OPTIONAL).
;       etc.

; 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

; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-GBK-FORMAT T T T)
;     (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-CRLF-GBK-FORMAT T T T)
;     (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-UTF-8-FORMAT T T T)
;     (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-CRLF-UTF-8-FORMAT T T T)
;     (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-UTF-16-FORMAT T T T)
;     (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; in:
;      DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-CRLF-UTF-16-LE-FORMAT T T T)
;     (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; in:
;      DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-CRLF-UTF-16-BE-FORMAT T T T)
;     (CHAR STRING FLEXI-STREAMS::I)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; in: DEFMETHOD COMPUTE-NUMBER-OF-OCTETS (FLEXI-UTF-32-FORMAT T T T)
;     (* 4 (- FLEXI-STREAMS::END FLEXI-STREAMS::START))
; 
; note: forced to do */SIGNED=>INTEGER (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
;                        (OR (INTEGER -36893488147419103228 -4) (INTEGER 0 0)
;                            (INTEGER 4 36893488147419103228))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       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
;                        (OR (INTEGER -36893488147419103228 -4) (INTEGER 0 0)
;                            (INTEGER 4 36893488147419103228))
;                        &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

; 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: 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; 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: 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 T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT
;                                                                &OPTIONAL).
;       etc.


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/flexi-streams-20240503-4951d57/length-tmpKOV75BS9.fasl
; compilation finished in 0:00:00.221
; compiling file "/workspace/ocicl/flexi-streams-20240503-4951d57/encode.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/flexi-streams-20240503-4951d57/encode.lisp
; in:
;      DEFINE-CHAR-ENCODERS (FLEXI-LATIN-1-FORMAT FLEXI-CR-LATIN-1-FORMAT
;                        FLEXI-CRLF-LATIN-1-FORMAT)
;     (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)))
; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not a LATIN-1 character."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (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)))
; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not a LATIN-1 character."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not a LATIN-1 character."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

;     (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)))
; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

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

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

; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF 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 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 COND IF IF 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 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

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

; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET 
; --> FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET 
; --> FLEXI-STREAMS::CHAR-GETTER AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; in:
;      DEFINE-CHAR-ENCODERS (FLEXI-ASCII-FORMAT FLEXI-CR-ASCII-FORMAT
;                        FLEXI-CRLF-ASCII-FORMAT)
;     (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)))
; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not an ASCII character."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (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)))
; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not an ASCII character."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not an ASCII character."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

;     (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)))
; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

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

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

; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF 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 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 COND IF IF 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 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

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

; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET 
; --> FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET 
; --> FLEXI-STREAMS::CHAR-GETTER AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; in:
;      DEFINE-CHAR-ENCODERS (FLEXI-8-BIT-FORMAT FLEXI-CR-8-BIT-FORMAT
;                        FLEXI-CRLF-8-BIT-FORMAT)
;     (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))))
; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not in this encoding."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (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))))
; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not in this encoding."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not in this encoding."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

;     (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))))
; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

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

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

; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY WITH-ACCESSORS LET 
; --> SYMBOL-MACROLET LET GETHASH 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF 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 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY WITH-ACCESSORS LET 
; --> SYMBOL-MACROLET LET GETHASH 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 COND IF IF 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 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

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

; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET 
; --> FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET 
; --> FLEXI-STREAMS::CHAR-GETTER AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; in:
;      DEFINE-CHAR-ENCODERS (FLEXI-UTF-8-FORMAT FLEXI-CR-UTF-8-FORMAT
;                        FLEXI-CRLF-UTF-8-FORMAT)
;     (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)))
; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (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)))
; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

;     (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)))
; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

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

; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

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

; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET 
; --> FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET 
; --> FLEXI-STREAMS::CHAR-GETTER AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; in:
;      DEFINE-CHAR-ENCODERS (FLEXI-UTF-16-LE-FORMAT FLEXI-CR-UTF-16-LE-FORMAT
;                        FLEXI-CRLF-UTF-16-LE-FORMAT)
;     (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 # # #)))))
; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (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 # # #)))))
; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

;     (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 # # #)))))
; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

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

; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

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

; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET 
; --> FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET 
; --> FLEXI-STREAMS::CHAR-GETTER AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; in:
;      DEFINE-CHAR-ENCODERS (FLEXI-UTF-16-BE-FORMAT FLEXI-CR-UTF-16-BE-FORMAT
;                        FLEXI-CRLF-UTF-16-BE-FORMAT)
;     (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 # # #)))))
; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (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 # # #)))))
; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

;     (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 # # #)))))
; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

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

; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

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

; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET 
; --> FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET 
; --> FLEXI-STREAMS::CHAR-GETTER AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; in:
;      DEFINE-CHAR-ENCODERS (FLEXI-GBK-FORMAT FLEXI-CR-GBK-FORMAT
;                        FLEXI-CRLF-GBK-FORMAT)
;     (FLEXI-STREAMS::LOGAND* 65280 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT)
;       (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (IF (<= FLEXI-STREAMS:OCTET 127)
;             (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET)
;             (FLET (#)
;               (DECLARE #)
;               (DECLARE #)
;               (COND # # #)))))
; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not in this encoding."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::LOGAND* 65280 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 65280 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 255 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT)
;       (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (IF (<= FLEXI-STREAMS:OCTET 127)
;             (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET)
;             (FLET (#)
;               (DECLARE #)
;               (DECLARE #)
;               (COND # # #)))))
; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not in this encoding."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::SIGNAL-ENCODING-ERROR FORMAT
;                                           "~S (code ~A) is not in this encoding."
;                                           FLEXI-STREAMS::CHAR-GETTER
;                                           FLEXI-STREAMS:OCTET)
; --> AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT)
;       (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (IF (<= FLEXI-STREAMS:OCTET 127)
;             (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET)
;             (FLET (#)
;               (DECLARE #)
;               (DECLARE #)
;               (COND # # #)))))
; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (FLEXI-STREAMS::LOGAND* 65280 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 65280 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 255 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::LOGAND* 65280 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 65280 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 255 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT)
;       (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (IF (<= FLEXI-STREAMS:OCTET 127)
;             (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET)
;             (FLET (#)
;               (DECLARE #)
;               (DECLARE #)
;               (COND # # #)))))
; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

;     (FLEXI-STREAMS::LOGAND* 65280 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 65280 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 255 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT)
;       (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (IF (<= FLEXI-STREAMS:OCTET 127)
;             (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET)
;             (FLET (#)
;               (DECLARE #)
;               (DECLARE #)
;               (COND # # #)))))
; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

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

; --> 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 IF FLET COND IF IF THE LET IF 
; --> FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::LOGAND* 65280 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 65280 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 255 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT)
;       (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (IF (<= FLEXI-STREAMS:OCTET 127)
;             (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET)
;             (FLET (#)
;               (DECLARE #)
;               (DECLARE #)
;               (COND # # #)))))
; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET IF FLET COND IF IF 
; --> THE LET IF FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET 
; --> FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET IF FLET COND IF IF 
; --> THE LET IF FLEXI-STREAMS::SIGNAL-ENCODING-ERROR LET 
; --> FLEXI-STREAMS::CHAR-GETTER AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (FLEXI-STREAMS::LOGAND* 65280 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 65280 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 255 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::LOGAND* 65280 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 65280 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 255 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT)
;       (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (IF (<= FLEXI-STREAMS:OCTET 127)
;             (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET)
;             (FLET (#)
;               (DECLARE #)
;               (DECLARE #)
;               (COND # # #)))))
; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

;     (FLEXI-STREAMS::LOGAND* 65280 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 65280 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 255 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT)
;       (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (IF (<= FLEXI-STREAMS:OCTET 127)
;             (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET)
;             (FLET (#)
;               (DECLARE #)
;               (DECLARE #)
;               (COND # # #)))))
; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

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

;     (FLEXI-STREAMS::LOGAND* 65280 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 65280 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 255 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT)
;       (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (IF (<= FLEXI-STREAMS:OCTET 127)
;             (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET)
;             (FLET (#)
;               (DECLARE #)
;               (DECLARE #)
;               (COND # # #)))))
; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET 
; --> FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET 
; --> FLEXI-STREAMS::CHAR-GETTER AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (FLEXI-STREAMS::LOGAND* 65280 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 65280 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 255 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::LOGAND* 65280 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 65280 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 255 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT)
;       (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (IF (<= FLEXI-STREAMS:OCTET 127)
;             (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET)
;             (FLET (#)
;               (DECLARE #)
;               (DECLARE #)
;               (COND # # #)))))
; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

;     (FLEXI-STREAMS::LOGAND* 65280 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 65280 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (NOT NULL), not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::LOGAND* 255 FLEXI-STREAMS::WORD)
; ==>
;   (LOGAND 255 FLEXI-STREAMS::WORD)
; 
; note: forced to do LOGAND-WORD-MASK/INTEGER-UNSIGNED-C (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (FLEXI-STREAMS::DEFINE-CHAR-ENCODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT)
;       (LET ((FLEXI-STREAMS:OCTET (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)))
;         (IF (<= FLEXI-STREAMS:OCTET 127)
;             (FLEXI-STREAMS::OCTET-WRITER FLEXI-STREAMS:OCTET)
;             (FLET (#)
;               (DECLARE #)
;               (DECLARE #)
;               (COND # # #)))))
; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; in:
;      DEFINE-CHAR-ENCODERS (FLEXI-UTF-32-LE-FORMAT FLEXI-CR-UTF-32-LE-FORMAT
;                        FLEXI-CRLF-UTF-32-LE-FORMAT)
;     (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)))))
; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (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)))))
; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

;     (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)))))
; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

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

; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

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

; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET 
; --> FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET 
; --> FLEXI-STREAMS::CHAR-GETTER AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; in:
;      DEFINE-CHAR-ENCODERS (FLEXI-UTF-32-BE-FORMAT FLEXI-CR-UTF-32-BE-FORMAT
;                        FLEXI-CRLF-UTF-32-BE-FORMAT)
;     (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))))
; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

;     (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))))
; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

;     (CHAR-CODE FLEXI-STREAMS::CHAR-GETTER)
; --> CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

;     (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))))
; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

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

; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY LET CHAR-CODE LET 
; --> FLEXI-STREAMS::CHAR-GETTER AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*

; --> 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 MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a (OR INTEGER
;                                                                   (CONS INTEGER
;                                                                         NULL)).

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

; --> 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 
; --> SB-C::WITH-SOURCE-FORM AREF LET* FUNCALL 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; note: unable to
;   convert division by 2^k to shift
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.
; 
; note: unable to
;   fold division by 1
; due to type uncertainty:
;   The first argument is a REAL, not a INTEGER.

; --> 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 COND IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET 
; --> FLEXI-STREAMS::CHAR-GETTER CHAR 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 COND IF IF FLEXI-STREAMS::ITERATE LOOP 
; --> BLOCK LET TAGBODY PROGN SYMBOL-MACROLET LOCALLY FLET LET 
; --> FLEXI-STREAMS::CHAR-GETTER AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (AND (NOT (ARRAY CHARACTER)) VECTOR
;                                (NOT (ARRAY BASE-CHAR))), not a SIMPLE-ARRAY.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN LET* COND IF THE LET POSITION 
; ==>
;   1
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a LIST.
; 
; note: unable to
;   expand inline
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL VECTOR).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR STRING NULL).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a (OR LIST VECTOR), not a (OR NULL BIT-VECTOR).

; --> 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 
; ==>
;   1
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -9223372036854775807
;                                 9223372036854775807), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.
; 
; note: forced to do <-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 SB-C::WITH-SOURCE-FORM 
; --> FLEXI-STREAMS:FLEXI-STREAM-COLUMN 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE
;                                                                                 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES
;                                                         (UNSIGNED-BYTE 64)
;                                                         &OPTIONAL).
;       etc.

; --> 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 
; ==>
;   1
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the second argument of GENERIC-*


; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/flexi-streams-20240503-4951d57/encode-tmpP07HWIXP.fasl
; compilation finished in 0:00:02.047
; compiling file "/workspace/ocicl/flexi-streams-20240503-4951d57/decode.lisp" (written 01 JAN 1970 12:00:01 AM):

; file: /workspace/ocicl/flexi-streams-20240503-4951d57/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)
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF 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 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 COND IF IF 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 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 COND IF IF IF 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 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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-C::WITH-SOURCE-FORM SCHAR SB-KERNEL:%SCHARSET 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; --> 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 COND IF 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 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 COND IF IF 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 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 COND IF IF IF 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 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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-C::WITH-SOURCE-FORM SCHAR SB-KERNEL:%SCHARSET 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; --> 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 COND IF 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 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 COND IF IF 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 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 COND IF IF IF 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 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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-C::WITH-SOURCE-FORM SCHAR SB-KERNEL:%SCHARSET 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; 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)))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (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))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; 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)))
; --> 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 COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK 
; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET WHEN 
; --> IF AND IF OR LET IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP 
; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET 
; --> WHEN IF AND IF OR LET IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK 
; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET WHEN 
; --> IF AND IF OR LET IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (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
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-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)))
; --> 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-C::WITH-SOURCE-FORM SCHAR SB-KERNEL:%SCHARSET 
; ==>
;   1
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (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))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; 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)))
; --> 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 COND IF IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF IF IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (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
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-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)))
; --> 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-C::WITH-SOURCE-FORM SCHAR SB-KERNEL:%SCHARSET 
; ==>
;   1
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (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))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; 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)))
; --> 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 COND IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF IF IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (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
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-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)))
; --> 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-C::WITH-SOURCE-FORM SCHAR SB-KERNEL:%SCHARSET 
; ==>
;   1
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; in:
;      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)))))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (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)))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; 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)))))
; --> 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 COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK 
; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET WHEN 
; --> IF AND IF OR LET IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP 
; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET 
; --> WHEN IF AND IF OR LET IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK 
; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET WHEN 
; --> IF AND IF OR LET IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (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
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-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)))))
; --> 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-C::WITH-SOURCE-FORM SCHAR SB-KERNEL:%SCHARSET 
; ==>
;   1
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (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)))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; 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)))))
; --> 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 COND IF IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF IF IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (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
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-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)))))
; --> 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-C::WITH-SOURCE-FORM SCHAR SB-KERNEL:%SCHARSET 
; ==>
;   1
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (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)))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; 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)))))
; --> 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 COND IF IF IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (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
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-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)))))
; --> 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-C::WITH-SOURCE-FORM SCHAR SB-KERNEL:%SCHARSET 
; ==>
;   1
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; in:
;      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 #
;               #
;               #)))))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;      "End of data while in UTF-8 sequence.")
; 
; note: deleting unreachable code

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-8 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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.

;     (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 #
;               #
;               #)))))
; --> 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 COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK 
; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET WHEN 
; --> IF AND IF OR LET IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP 
; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET 
; --> WHEN IF AND IF OR LET IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK 
; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET WHEN 
; --> IF AND IF OR LET IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;      "End of data while in UTF-8 sequence.")
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-8 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-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 #
;               #
;               #)))))
; --> 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-C::WITH-SOURCE-FORM SCHAR SB-KERNEL:%SCHARSET 
; ==>
;   1
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;      "End of data while in UTF-8 sequence.")
; 
; note: deleting unreachable code

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-8 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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.

;     (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 #
;               #
;               #)))))
; --> 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 COND IF IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF IF IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;      "End of data while in UTF-8 sequence.")
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-8 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-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 #
;               #
;               #)))))
; --> 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-C::WITH-SOURCE-FORM SCHAR SB-KERNEL:%SCHARSET 
; ==>
;   1
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;      "End of data while in UTF-8 sequence.")
; 
; note: deleting unreachable code

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-8 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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.

;     (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 #
;               #
;               #)))))
; --> 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 COND IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF IF IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;       (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;        "End of data while in UTF-8 sequence."))
; 
; note: deleting unreachable code

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)
; 
; note: deleting unreachable code

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;       (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;        "End of data while in UTF-8 sequence."))
; 
; note: deleting unreachable code

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)
; 
; note: deleting unreachable code

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;       (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;        "End of data while in UTF-8 sequence."))
; 
; note: deleting unreachable code

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)
; 
; note: deleting unreachable code

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-8 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-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 #
;               #
;               #)))))
; --> 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-C::WITH-SOURCE-FORM SCHAR SB-KERNEL:%SCHARSET 
; ==>
;   1
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;       (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;        "End of data while in UTF-8 sequence."))
; 
; note: deleting unreachable code

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)
; 
; note: deleting unreachable code

; in:
;      DEFINE-CHAR-DECODERS (FLEXI-UTF-16-LE-FORMAT FLEXI-CR-UTF-16-LE-FORMAT
;                        FLEXI-CRLF-UTF-16-LE-FORMAT)
;     (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;      "End of data while in UTF-16 sequence.")
; 
; note: deleting unreachable code

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-16 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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.

;     (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;      "End of data while in UTF-16 sequence.")
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-16 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; --> FLEXI-STREAMS::OCTET-GETTER AND IF PROG1 LET THE AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;      "End of data while in UTF-16 sequence.")
; 
; note: deleting unreachable code

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-16 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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.

;     (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;      "End of data while in UTF-16 sequence.")
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-16 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; --> FLEXI-STREAMS::OCTET-GETTER AND IF PROG1 LET THE AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;      "End of data while in UTF-16 sequence.")
; 
; note: deleting unreachable code

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-16 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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.

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;       (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;        "End of data while in UTF-16 sequence."))
; 
; note: deleting unreachable code

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;       (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;        "End of data while in UTF-16 sequence."))
; 
; note: deleting unreachable code

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;       (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;        "End of data while in UTF-16 sequence."))
; 
; note: deleting unreachable code

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-16 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; --> FLEXI-STREAMS::OCTET-GETTER AND IF PROG1 LET THE AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;       (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;        "End of data while in UTF-16 sequence."))
; 
; note: deleting unreachable code

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

; in:
;      DEFINE-CHAR-DECODERS (FLEXI-UTF-16-BE-FORMAT FLEXI-CR-UTF-16-BE-FORMAT
;                        FLEXI-CRLF-UTF-16-BE-FORMAT)
;     (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;      "End of data while in UTF-16 sequence.")
; 
; note: deleting unreachable code

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-16 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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.

;     (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;      "End of data while in UTF-16 sequence.")
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-16 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; --> FLEXI-STREAMS::OCTET-GETTER AND IF PROG1 LET THE AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;      "End of data while in UTF-16 sequence.")
; 
; note: deleting unreachable code

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-16 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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.

;     (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;      "End of data while in UTF-16 sequence.")
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-16 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; --> FLEXI-STREAMS::OCTET-GETTER AND IF PROG1 LET THE AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;      "End of data while in UTF-16 sequence.")
; 
; note: deleting unreachable code

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-16 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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
;   optimize
; 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.

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;       (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;        "End of data while in UTF-16 sequence."))
; 
; note: deleting unreachable code

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;       (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;        "End of data while in UTF-16 sequence."))
; 
; note: deleting unreachable code

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;       (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;        "End of data while in UTF-16 sequence."))
; 
; note: deleting unreachable code

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-16 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

; --> FLEXI-STREAMS::OCTET-GETTER AND IF PROG1 LET THE AREF 
; ==>
;   1
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;       (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;        "End of data while in UTF-16 sequence."))
; 
; note: deleting unreachable code

;     (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL)
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

; in:
;      DEFINE-CHAR-DECODERS (FLEXI-GBK-FORMAT FLEXI-CR-GBK-FORMAT
;                        FLEXI-CRLF-GBK-FORMAT)
;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT)
;       (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;         (COND ((<= # 127) FLEXI-STREAMS:OCTET) ((= # 128) 8364) ((= # 255) 63733)
;               (T
;                (LET #
;                  #)))))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (COND
;        ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;         FLEXI-STREAMS:OCTET)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733)
;        (T
;         (LET (#)
;           (IF #
;               #
;               #)))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER)
; --> BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (COND
;        ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;         FLEXI-STREAMS:OCTET)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733)
;        (T
;         (LET (#)
;           (IF #
;               #
;               #)))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER)
; --> BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (COND
;        ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;         FLEXI-STREAMS:OCTET)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733)
;        (T
;         (LET (#)
;           (IF #
;               #
;               #)))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER)
; --> BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT)
;       (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;         (COND ((<= # 127) FLEXI-STREAMS:OCTET) ((= # 128) 8364) ((= # 255) 63733)
;               (T
;                (LET #
;                  #)))))
; --> 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 COND IF IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK 
; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET WHEN 
; --> IF AND IF OR LET IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF IF IF FLEXI-STREAMS::ITERATE FLET LOOP 
; --> BLOCK TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET 
; --> WHEN IF AND IF OR LET IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF FLEXI-STREAMS::ITERATE FLET LOOP BLOCK 
; --> TAGBODY PROGN LET PROGN SYMBOL-MACROLET MACROLET BLOCK LOCALLY LET WHEN 
; --> IF AND IF OR LET IF 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (COND
;        ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;         FLEXI-STREAMS:OCTET)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733)
;        (T
;         (LET (#)
;           (IF #
;               #
;               #)))))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT)
;       (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;         (COND ((<= # 127) FLEXI-STREAMS:OCTET) ((= # 128) 8364) ((= # 255) 63733)
;               (T
;                (LET #
;                  #)))))
; --> 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-C::WITH-SOURCE-FORM SCHAR SB-KERNEL:%SCHARSET 
; ==>
;   1
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (COND
;        ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;         FLEXI-STREAMS:OCTET)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733)
;        (T
;         (LET (#)
;           (IF #
;               #
;               #)))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER)
; --> BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (COND
;        ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;         FLEXI-STREAMS:OCTET)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733)
;        (T
;         (LET (#)
;           (IF #
;               #
;               #)))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER)
; --> BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (COND
;        ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;         FLEXI-STREAMS:OCTET)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733)
;        (T
;         (LET (#)
;           (IF #
;               #
;               #)))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER)
; --> BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT)
;       (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;         (COND ((<= # 127) FLEXI-STREAMS:OCTET) ((= # 128) 8364) ((= # 255) 63733)
;               (T
;                (LET #
;                  #)))))
; --> 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 COND IF IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF IF IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (COND
;        ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;         FLEXI-STREAMS:OCTET)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733)
;        (T
;         (LET (#)
;           (IF #
;               #
;               #)))))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT)
;       (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;         (COND ((<= # 127) FLEXI-STREAMS:OCTET) ((= # 128) 8364) ((= # 255) 63733)
;               (T
;                (LET #
;                  #)))))
; --> 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-C::WITH-SOURCE-FORM SCHAR SB-KERNEL:%SCHARSET 
; ==>
;   1
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (COND
;        ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;         FLEXI-STREAMS:OCTET)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733)
;        (T
;         (LET (#)
;           (IF #
;               #
;               #)))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER)
; --> BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (COND
;        ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;         FLEXI-STREAMS:OCTET)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733)
;        (T
;         (LET (#)
;           (IF #
;               #
;               #)))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER)
; --> BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (COND
;        ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;         FLEXI-STREAMS:OCTET)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733)
;        (T
;         (LET (#)
;           (IF #
;               #
;               #)))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER)
; --> BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT)
;       (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;         (COND ((<= # 127) FLEXI-STREAMS:OCTET) ((= # 128) 8364) ((= # 255) 63733)
;               (T
;                (LET #
;                  #)))))
; --> 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 COND IF IF IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> 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 COND IF 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 
; ==>
;   (> #:CHAR-CODE0 1114111)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;       (COND
;        ((<= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 127)
;         FLEXI-STREAMS:OCTET)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 128) 8364)
;        ((= (THE FLEXI-STREAMS:OCTET FLEXI-STREAMS:OCTET) 255) 63733)
;        (T
;         (LET (#)
;           (IF #
;               #
;               #)))))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::NEXT-BYTE FLEXI-STREAMS::OCTET-GETTER)
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (FLEXI-STREAMS::DEFINE-CHAR-DECODERS (FLEXI-STREAMS::FLEXI-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CR-GBK-FORMAT
;                                           FLEXI-STREAMS::FLEXI-CRLF-GBK-FORMAT)
;       (FLEXI-STREAMS::WHEN-LET (FLEXI-STREAMS:OCTET FLEXI-STREAMS::OCTET-GETTER)
;         (COND ((<= # 127) FLEXI-STREAMS:OCTET) ((= # 128) 8364) ((= # 255) 63733)
;               (T
;                (LET #
;                  #)))))
; --> 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-C::WITH-SOURCE-FORM SCHAR SB-KERNEL:%SCHARSET 
; ==>
;   1
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; in:
;      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 ...)
; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:SUM21 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-32 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (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 ...)
; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:SUM146 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

; ==>
;   (+ #:SUM163 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

; ==>
;   (+ #:SUM126 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-32 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-32 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (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 ...)
; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:SUM436 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

; ==>
;   (+ #:SUM453 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

; ==>
;   (+ #:SUM416 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-32 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-32 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (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 ...)
; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:SUM741 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

; ==>
;   (+ #:SUM704 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

; ==>
;   (+ #:SUM724 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-32 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

; 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 ...)
; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:SUM21 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-32 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (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 ...)
; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:SUM146 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

; ==>
;   (+ #:SUM163 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

; ==>
;   (+ #:SUM126 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-32 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-32 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (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 ...)
; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:SUM436 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

; ==>
;   (+ #:SUM453 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

; ==>
;   (+ #:SUM416 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-32 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-32 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; --> FLEXI-STREAMS::OCTET-GETTER BLOCK PROG1 LET AREF 
; ==>
;   1
; 
; note: unable to
;   optimize
; 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
;   optimize
; due to type uncertainty:
;   The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (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 ...)
; --> LET LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:SUM704 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

; ==>
;   (+ #:SUM741 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

; ==>
;   (+ #:SUM724 (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
;                                                                       &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) 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)
;                                                                &OPTIONAL).
;       etc.

;     (OR FLEXI-STREAMS::OCTET-GETTER
;         (COND
;          (FLEXI-STREAMS::FIRST-OCTET-SEEN
;           (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER
;             (FLEXI-STREAMS::RECOVER-FROM-ENCODING-ERROR FORMAT
;              "End of data while in UTF-32 sequence.")))
;          (T (RETURN-FROM FLEXI-STREAMS::CHAR-DECODER NIL))))
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (LOOP 

sbcl --non-interactive --eval '(push (truename ".") asdf:*central-registry*)' --eval '(asdf:load-system :usher/test)' \
        --eval '(uiop:quit (if (uiop:symbol-call :fiveam :run! (uiop:find-symbol* :usher :usher/test)) 0 1))'
This is SBCL 2.6.3-1.fc44, 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"/workspace/ocicl/trivial-utf-8-20240503-ba9b4ff/trivial-utf-8.asd" contains definition for system "trivial-utf-8-tests". Please only define "trivial-utf-8" and secondary systems with a name starting with "trivial-utf-8/" (e.g. "trivial-utf-8/test") in that file.
WARNING: redefining IRONCLAD:BLOCK-LENGTH in DEFGENERIC
; compiling file "/workspace/ocicl/asdf-flv-20240503-3f1de41/package.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/asdf-flv-20240503-3f1de41/package-tmpGHU3ALSV.fasl
; compilation finished in 0:00:00.002
; compiling file "/workspace/ocicl/asdf-flv-20240503-3f1de41/asdf-flv.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/asdf-flv-20240503-3f1de41/asdf-flv-tmpAAURSO1.fasl
; compilation finished in 0:00:00.025
; compiling file "/workspace/ocicl/fiveam-20240928-e43d6c8/src/package.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/fiveam-20240928-e43d6c8/src/package-tmp5GEXGEG5.fasl
; compilation finished in 0:00:00.003
; compiling file "/workspace/ocicl/fiveam-20240928-e43d6c8/src/utils.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/fiveam-20240928-e43d6c8/src/utils-tmpAR3FSGEY.fasl
; compilation finished in 0:00:00.056
; compiling file "/workspace/ocicl/fiveam-20240928-e43d6c8/src/check.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/fiveam-20240928-e43d6c8/src/check-tmpJAIDFZTC.fasl
; compilation finished in 0:00:00.117
; compiling file "/workspace/ocicl/fiveam-20240928-e43d6c8/src/fixture.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/fiveam-20240928-e43d6c8/src/fixture-tmp8V3J6PE9.fasl
; compilation finished in 0:00:00.013
; compiling file "/workspace/ocicl/fiveam-20240928-e43d6c8/src/classes.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/fiveam-20240928-e43d6c8/src/classes-tmp9V47YWQF.fasl
; compilation finished in 0:00:00.013
; compiling file "/workspace/ocicl/fiveam-20240928-e43d6c8/src/random.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/fiveam-20240928-e43d6c8/src/random-tmp9BN22RMA.fasl
; compilation finished in 0:00:00.122
; compiling file "/workspace/ocicl/fiveam-20240928-e43d6c8/src/test.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/fiveam-20240928-e43d6c8/src/test-tmp1CXFJSK9.fasl
; compilation finished in 0:00:00.020
; compiling file "/workspace/ocicl/fiveam-20240928-e43d6c8/src/explain.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/fiveam-20240928-e43d6c8/src/explain-tmpX4BRKI0R.fasl
; compilation finished in 0:00:00.022
; compiling file "/workspace/ocicl/fiveam-20240928-e43d6c8/src/suite.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/fiveam-20240928-e43d6c8/src/suite-tmpQ371UGST.fasl
; compilation finished in 0:00:00.024
; compiling file "/workspace/ocicl/fiveam-20240928-e43d6c8/src/run.lisp" (written 01 JAN 1970 12:00:01 AM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/ocicl/fiveam-20240928-e43d6c8/src/run-tmp2OWI3Q7U.fasl
; compilation finished in 0:00:00.099
; compiling file "/workspace/test/suite.lisp" (written 28 JUN 2026 05:05:11 PM):

; wrote /root/.cache/common-lisp/sbcl-2.6.3-1.fc44-linux-x64-s/workspace/test/suite-tmp9KKTJMYV.fasl
; compilation finished in 0:00:00.035

Running test suite USHER
 Running test PASSWORD-HASH-ROUNDTRIP ...
 Running test PASSWORD-HASHES-ARE-SALTED .
 Running test BASE64URL-ROUNDTRIP ..
 Running test RANDOM-UUID-SHAPE ..
 Running test PKCE-S256 ..
 Running test JWKS-SHAPE .....
 Running test ACCESS-TOKEN-VALIDATES