Python version 1.0, VM version Intel x86 on 19 NOV 8 01:25:19 pm.
Compiling: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp 13 MAY 8 01:07:13 pm

Byte Compiling Top-Level Form: 
Converted DBREF.
Compiling DEFMACRO DBREF: 
Converted PLUS.
Compiling DEFMACRO PLUS: 
Converted MINUS.
Compiling DEFMACRO MINUS: 
Converted MUL.
Compiling DEFMACRO MUL: 
Converted DEFINE-CONSTANT.
Compiling DEFMACRO DEFINE-CONSTANT: 
Byte Compiling Top-Level Form: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In:
    WHEN (/= (INTEGER-LENGTH MOST-POSITIVE-FIXNUM)
          (INTEGER-LENGTH MOST-NEGATIVE-FIXNUM))
  (ERROR "Can't compile with asymmetric fixnums!")
Note: Deleting unreachable code.

Byte Compiling Top-Level Form: 
Byte Compiling Top-Level Form: 
Byte Compiling Top-Level Form: 
Compiling DEFVAR *QUANTIZE-OPTIMIZATION*: 
Byte Compiling Top-Level Form: 
Compiling DEFINE-CONSTANT *CSIZE*: 
Byte Compiling Top-Level Form: 
Byte Compiling Top-Level Form: 
Byte Compiling Top-Level Form: 
Compiling LOOP FOR: 
Byte Compiling Top-Level Form: 
Byte Compiling Top-Level Form: 
Compiling LOOP FOR: 
Byte Compiling Top-Level Form: 
Compiling DEFVAR *WS*: 
Byte Compiling Top-Level Form: 
Byte Compiling Top-Level Form: 
Compiling LOOP FOR: 
Byte Compiling Top-Level Form: 
Compiling LOOP FOR: 
Converted SUBSAMPLE.
Compiling DEFUN SUBSAMPLE: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN SUBSAMPLE
  (MUL BY H)
--> THE 
==>
  (* (THE FIXNUM BY) (THE FIXNUM H))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a (INTEGER -536870907 536870911), not a (UNSIGNED-BYTE
                                                                     32).
      The second argument is a (INTEGER -536870906 536870911), not a (UNSIGNED-BYTE
                                                                      32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

Converted COUNT-RELATION.
Compiling DEFUN COUNT-RELATION: 
Converted CROP-IMAGE.
Compiling DEFUN CROP-IMAGE: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN CROP-IMAGE
  (* W YD NCOMP)
--> * 
==>
  (* W YD)
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a (INTEGER -288230375614840832 288230376151711744), not a (UNSIGNED-BYTE
                                                                               32).

==>
  (* (* W YD) NCOMP)
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a (INTEGER -288230375614840832 288230376151711744), not a (UNSIGNED-BYTE
                                                                                       32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL XD NCOMP)
--> THE 
==>
  (* (THE FIXNUM XD) (THE FIXNUM NCOMP))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (* W YD NCOMP)
--> * 
==>
  (* W YD)
Note: Forced to do GENERIC-* (cost 30).
      Unable to do inline fixnum arithmetic (cost 4) because:
      The result is a (INTEGER -288230375614840832 288230376151711744), not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The result is a (INTEGER -288230375614840832 288230376151711744), not a (SIGNED-BYTE
                                                                               32).
      etc.

==>
  (* (* W YD) NCOMP)
Note: Forced to do GENERIC-* (cost 30).
      Unable to do inline fixnum arithmetic (cost 4) because:
      The first argument is a (INTEGER -288230375614840832 288230376151711744), not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a (INTEGER -288230375614840832 288230376151711744), not a (SIGNED-BYTE
                                                                                       32).
      etc.

Converted COLORSPACE-CONVERT.
Compiling DEFUN COLORSPACE-CONVERT: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN COLORSPACE-CONVERT
  (* W YD 3)
--> * 
==>
  (* W YD)
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a (INTEGER -288230375614840832 288230376151711744), not a (UNSIGNED-BYTE
                                                                               32).

==>
  (* (* W YD) 3)
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a (INTEGER -288230375614840832 288230376151711744), not a (UNSIGNED-BYTE
                                                                                       32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL XD 3)
--> THE 
==>
  (* (THE FIXNUM XD) (THE FIXNUM 3))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (+ (SVREF *CTAB* (PLUS R R-Y-OFF))
     (SVREF *CTAB* (PLUS G G-Y-OFF))
     (SVREF *CTAB* (PLUS B B-Y-OFF)))
--> + 
==>
  (+ (SVREF *CTAB* (PLUS R R-Y-OFF)) (SVREF *CTAB* (PLUS G G-Y-OFF)))
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a RATIONAL.
      The second argument is a NUMBER, not a FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
      The second argument is a NUMBER, not a RATIONAL.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

==>
  (+ (+ (SVREF *CTAB* #) (SVREF *CTAB* #)) (SVREF *CTAB* (PLUS B B-Y-OFF)))
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a RATIONAL.
      The second argument is a NUMBER, not a FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
      The second argument is a NUMBER, not a RATIONAL.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

  (+ (SVREF *CTAB* (PLUS R R-U-OFF))
     (SVREF *CTAB* (PLUS G G-U-OFF))
     (SVREF *CTAB* (PLUS B B-U-OFF)))
--> + 
==>
  (+ (SVREF *CTAB* (PLUS R R-U-OFF)) (SVREF *CTAB* (PLUS G G-U-OFF)))
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a RATIONAL.
      The second argument is a NUMBER, not a FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
      The second argument is a NUMBER, not a RATIONAL.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

==>
  (+ (+ (SVREF *CTAB* #) (SVREF *CTAB* #)) (SVREF *CTAB* (PLUS B B-U-OFF)))
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a RATIONAL.
      The second argument is a NUMBER, not a FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
      The second argument is a NUMBER, not a RATIONAL.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

  (+ (SVREF *CTAB* (PLUS R R-V-OFF))
     (SVREF *CTAB* (PLUS G G-V-OFF))
     (SVREF *CTAB* (PLUS B B-V-OFF)))
--> + 
==>
  (+ (SVREF *CTAB* (PLUS R R-V-OFF)) (SVREF *CTAB* (PLUS G G-V-OFF)))
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a RATIONAL.
      The second argument is a NUMBER, not a FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
      The second argument is a NUMBER, not a RATIONAL.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

==>
  (+ (+ (SVREF *CTAB* #) (SVREF *CTAB* #)) (SVREF *CTAB* (PLUS B B-V-OFF)))
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a RATIONAL.
      The second argument is a NUMBER, not a FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
      The second argument is a NUMBER, not a RATIONAL.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

  (* W YD 3)
--> * 
==>
  (* W YD)
Note: Forced to do GENERIC-* (cost 30).
      Unable to do inline fixnum arithmetic (cost 4) because:
      The result is a (INTEGER -288230375614840832 288230376151711744), not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The result is a (INTEGER -288230375614840832 288230376151711744), not a (SIGNED-BYTE
                                                                               32).
      etc.

==>
  (* (* W YD) 3)
Note: Forced to do GENERIC-* (cost 30).
      Unable to do inline fixnum arithmetic (cost 3) because:
      The first argument is a (INTEGER -288230375614840832 288230376151711744), not a FIXNUM.
      Unable to do inline fixnum arithmetic (cost 4) because:
      The first argument is a (INTEGER -288230375614840832 288230376151711744), not a FIXNUM.
      etc.

  (+ (SVREF *CTAB* (PLUS R R-Y-OFF))
     (SVREF *CTAB* (PLUS G G-Y-OFF))
     (SVREF *CTAB* (PLUS B B-Y-OFF)))
--> + 
==>
  (+ (SVREF *CTAB* (PLUS R R-Y-OFF)) (SVREF *CTAB* (PLUS G G-Y-OFF)))
Note: Forced to do GENERIC-+ (cost 10).
      Unable to do inline float arithmetic (cost 2) because:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
      The result is a NUMBER, not a DOUBLE-FLOAT.
      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 NUMBER, not a SINGLE-FLOAT.
      etc.

==>
  (+ (+ (SVREF *CTAB* #) (SVREF *CTAB* #)) (SVREF *CTAB* (PLUS B B-Y-OFF)))
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 INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The second argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

  (ASH (+ (SVREF *CTAB* #) (SVREF *CTAB* #) (SVREF *CTAB* #)) (- SHIFT))
Note: Forced to do full call.
      Unable to do inline ASH (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

  (+ (SVREF *CTAB* (PLUS R R-U-OFF))
     (SVREF *CTAB* (PLUS G G-U-OFF))
     (SVREF *CTAB* (PLUS B B-U-OFF)))
--> + 
==>
  (+ (SVREF *CTAB* (PLUS R R-U-OFF)) (SVREF *CTAB* (PLUS G G-U-OFF)))
Note: Forced to do GENERIC-+ (cost 10).
      Unable to do inline float arithmetic (cost 2) because:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
      The result is a NUMBER, not a DOUBLE-FLOAT.
      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 NUMBER, not a SINGLE-FLOAT.
      etc.

==>
  (+ (+ (SVREF *CTAB* #) (SVREF *CTAB* #)) (SVREF *CTAB* (PLUS B B-U-OFF)))
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 INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The second argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

  (ASH (+ (SVREF *CTAB* #) (SVREF *CTAB* #) (SVREF *CTAB* #)) (- SHIFT))
Note: Forced to do full call.
      Unable to do inline ASH (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

  (+ (SVREF *CTAB* (PLUS R R-V-OFF))
     (SVREF *CTAB* (PLUS G G-V-OFF))
     (SVREF *CTAB* (PLUS B B-V-OFF)))
--> + 
==>
  (+ (SVREF *CTAB* (PLUS R R-V-OFF)) (SVREF *CTAB* (PLUS G G-V-OFF)))
Note: Forced to do GENERIC-+ (cost 10).
      Unable to do inline float arithmetic (cost 2) because:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
      The result is a NUMBER, not a DOUBLE-FLOAT.
      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 NUMBER, not a SINGLE-FLOAT.
      etc.

==>
  (+ (+ (SVREF *CTAB* #) (SVREF *CTAB* #)) (SVREF *CTAB* (PLUS B B-V-OFF)))
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 INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The second argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

  (ASH (+ (SVREF *CTAB* #) (SVREF *CTAB* #) (SVREF *CTAB* #)) (- SHIFT))
Note: Forced to do full call.
      Unable to do inline ASH (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

Converted CONVERT-SAMPLING.
Compiling DEFUN CONVERT-SAMPLING: 
Byte Compiling Top-Level Form: 
Converted QUANTIZE-BLOCK.
Compiling DEFMACRO QUANTIZE-BLOCK: 
Converted QUANTIZE.
Compiling DEFUN QUANTIZE: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN QUANTIZE
  (QUANTIZE-BLOCK)
--> LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ 
--> SETQ 
==>
  (ASH (SVREF BLOCK-ROW X) -3)
Note: Forced to do full call.
      Unable to do inline ASH (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

Converted DESCALE.
Compiling DEFUN DESCALE: 
Converted PLUS3.
Compiling DEFMACRO PLUS3: 
Converted LLM-DCT.
Compiling DEFUN LLM-DCT: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN LLM-DCT
  (MUL (PLUS TMP12 TMP13) FIX-0-541196100)
--> THE 
==>
  (* (THE FIXNUM (PLUS TMP12 TMP13)) (THE FIXNUM FIX-0-541196100))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL TMP13 FIX-0-765366865)
--> THE 
==>
  (* (THE FIXNUM TMP13) (THE FIXNUM FIX-0-765366865))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL (PLUS Z3 Z4) FIX-1-175875602)
--> THE 
==>
  (* (THE FIXNUM (PLUS Z3 Z4)) (THE FIXNUM FIX-1-175875602))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL TMP4 FIX-0-298631336)
--> THE 
==>
  (* (THE FIXNUM TMP4) (THE FIXNUM FIX-0-298631336))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL TMP5 FIX-2-053119869)
--> THE 
==>
  (* (THE FIXNUM TMP5) (THE FIXNUM FIX-2-053119869))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL TMP6 FIX-3-072711026)
--> THE 
==>
  (* (THE FIXNUM TMP6) (THE FIXNUM FIX-3-072711026))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL TMP7 FIX-1-501321110)
--> THE 
==>
  (* (THE FIXNUM TMP7) (THE FIXNUM FIX-1-501321110))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL (PLUS TMP12 TMP13) FIX-0-541196100)
--> THE 
==>
  (* (THE FIXNUM (PLUS TMP12 TMP13)) (THE FIXNUM FIX-0-541196100))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL TMP13 FIX-0-765366865)
--> THE 
==>
  (* (THE FIXNUM TMP13) (THE FIXNUM FIX-0-765366865))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL (PLUS Z3 Z4) FIX-1-175875602)
--> THE 
==>
  (* (THE FIXNUM (PLUS Z3 Z4)) (THE FIXNUM FIX-1-175875602))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL TMP4 FIX-0-298631336)
--> THE 
==>
  (* (THE FIXNUM TMP4) (THE FIXNUM FIX-0-298631336))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL TMP5 FIX-2-053119869)
--> THE 
==>
  (* (THE FIXNUM TMP5) (THE FIXNUM FIX-2-053119869))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL TMP6 FIX-3-072711026)
--> THE 
==>
  (* (THE FIXNUM TMP6) (THE FIXNUM FIX-3-072711026))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL TMP7 FIX-1-501321110)
--> THE 
==>
  (* (THE FIXNUM TMP7) (THE FIXNUM FIX-1-501321110))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (SETF (SVREF DPTR 0) (ASH (PLUS TMP10 TMP11) 1))
--> COMMON-LISP::%SVSET COMMON-LISP::%ASET LET* 
==>
  (KERNEL:DATA-VECTOR-SET ARRAY KERNEL:INDEX C::NEW-VALUE)
Note: Doing signed word to integer coercion (cost 20), for:
      The second argument of DATA-VECTOR-SET/SIMPLE-VECTOR-C.

  (SETF (SVREF DPTR 4) (ASH (MINUS TMP10 TMP11) 1))
--> COMMON-LISP::%SVSET COMMON-LISP::%ASET LET* 
==>
  (KERNEL:DATA-VECTOR-SET ARRAY KERNEL:INDEX C::NEW-VALUE)
Note: Doing signed word to integer coercion (cost 20), for:
      The second argument of DATA-VECTOR-SET/SIMPLE-VECTOR-C.

Converted CRUNCH.
Compiling DEFUN CRUNCH: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN CRUNCH
  (LLM-DCT (SVREF BUF POS))
--> BLOCK LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN LOOP LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN SETF SETQ MUL THE 
==>
  (* (THE FIXNUM (PLUS TMP12 TMP13)) (THE FIXNUM FIX-0-541196100))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

--> BLOCK LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN LOOP LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN SETF LET* 
--> MULTIPLE-VALUE-BIND LET DESCALE PLUS THE + THE MUL THE 
==>
  (* (THE FIXNUM TMP13) (THE FIXNUM FIX-0-765366865))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

--> BLOCK LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN LOOP LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN SETF SETQ MUL THE 
==>
  (* (THE FIXNUM (PLUS Z3 Z4)) (THE FIXNUM FIX-1-175875602))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP4) (THE FIXNUM FIX-0-298631336))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP5) (THE FIXNUM FIX-2-053119869))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP6) (THE FIXNUM FIX-3-072711026))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP7) (THE FIXNUM FIX-1-501321110))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM (PLUS TMP12 TMP13)) (THE FIXNUM FIX-0-541196100))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

--> BLOCK LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN LOOP LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN SETF COMMON-LISP::%SVSET 
--> COMMON-LISP::%ASET DESCALE PLUS THE + THE MUL THE 
==>
  (* (THE FIXNUM TMP13) (THE FIXNUM FIX-0-765366865))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

--> BLOCK LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN LOOP LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN SETF SETQ MUL THE 
==>
  (* (THE FIXNUM (PLUS Z3 Z4)) (THE FIXNUM FIX-1-175875602))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP4) (THE FIXNUM FIX-0-298631336))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP5) (THE FIXNUM FIX-2-053119869))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP6) (THE FIXNUM FIX-3-072711026))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP7) (THE FIXNUM FIX-1-501321110))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (QUANTIZE (SVREF BUF POS) TABLE)
--> BLOCK QUANTIZE-BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LOOP LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ 
==>
  (ASH (SVREF BLOCK-ROW X) -3)
Note: Forced to do full call.
      Unable to do inline ASH (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

  (LLM-DCT (SVREF BUF POS))
--> BLOCK LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN LOOP LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN SETF COMMON-LISP::%SVSET 
--> COMMON-LISP::%ASET LET* 
==>
  (KERNEL:DATA-VECTOR-SET ARRAY KERNEL:INDEX C::NEW-VALUE)
Note: Doing signed word to integer coercion (cost 20), for:
      The second argument of DATA-VECTOR-SET/SIMPLE-VECTOR-C.
[Last message occurs 2 times]

Converted Q-SCALE.
Compiling DEFUN Q-SCALE: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN Q-SCALE
  (/= Q-FACTOR 64)
--> IF 
==>
  (= Q-FACTOR 64)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
Note: Unable to open code because:
      Operands might not be the same type.

  (/ Q-FACTOR 64)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a INTEGER.

  (LOOP FOR Q-ROW ACROSS TABLE ...)
--> LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY SETQ 
==>
  (LENGTH #:G0)
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a (SIMPLE-ARRAY * (*)).
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a VECTOR.

  (* (SVREF Q-ROW X) FACTOR)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a RATIONAL.
      The second argument is a NUMBER, not a FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
      The second argument is a NUMBER, not a RATIONAL.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
Note: Unable to convert x*2^k to shift due to type uncertainty:
      The first argument is a NUMBER, not a INTEGER.
      The second argument is a NUMBER, not a INTEGER.
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a NUMBER, not a (UNSIGNED-BYTE 32).
      The second argument is a NUMBER, not a (UNSIGNED-BYTE 32).
      The result is a REAL, not a (UNSIGNED-BYTE 32).

  (LOOP FOR Q-ROW ACROSS TABLE ...)
--> LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF LET* 
==>
  (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
Note: Unable to optimize due to type uncertainty:
      The first argument is a VECTOR, not a SIMPLE-ARRAY.
Note: Forced to do full call.
      Unable to do inline array access (cost 5) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY
                                             (COMPLEX SINGLE-FLOAT) (*)).
      The result is a T, not a (COMPLEX SINGLE-FLOAT).
      Unable to do inline array access (cost 5) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
      The result is a T, not a SINGLE-FLOAT.
      etc.

  (* (SVREF Q-ROW X) FACTOR)
Note: Forced to do GENERIC-* (cost 30).
      Unable to do inline float arithmetic (cost 3) 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 REAL, not a SINGLE-FLOAT.
      Unable to do inline float arithmetic (cost 3) because:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
      The result is a REAL, not a DOUBLE-FLOAT.
      etc.

  (ROUND (* (SVREF Q-ROW X) FACTOR))
--> ROUND LET 
==>
  (KERNEL:%UNARY-ROUND C::X)
Note: Forced to do full call.
      Unable to do inline float truncate (cost 5) because:
      The first argument is a REAL, not a SINGLE-FLOAT.
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).
      Unable to do inline float truncate (cost 5) because:
      The first argument is a REAL, not a SINGLE-FLOAT.
      etc.

Converted CSIZE.
Compiling DEFUN CSIZE: 
Converted ZIGZAG.
Compiling DEFUN ZIGZAG: 
Converted WRITE-FRAME-HEADER.
Compiling DEFUN WRITE-FRAME-HEADER: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN WRITE-FRAME-HEADER
  (DEPOSIT-FIELD (SECOND ENTRY) (BYTE 4 0) (ASH (FIRST ENTRY) 4))
==>
  (KERNEL:%DEPOSIT-FIELD (SECOND ENTRY) 4 0 (ASH (FIRST ENTRY) 4))
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (SIGNED-BYTE 32).

  (MUL 3 CN)
--> THE * 
==>
  (* C::Y 3)
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (ASH (FIRST ENTRY) 4)
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 INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      etc.

Converted WRITE-STUFFED.
Compiling DEFUN WRITE-STUFFED: 
Byte Compiling Top-Level Form: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN WRITE-BITS
  (LET ((B #) (N #))
    (DECLARE (TYPE FIXNUM B N) (DYNAMIC-EXTENT B N))
    (COND (#) (# #) (T # #)))
Note: DYNAMIC-EXTENT declaration not implemented.

  (LET* ((RESULT #) (TOTAL-LENGTH #) (OVERFLOW #))
    (DECLARE (TYPE FIXNUM OVERFLOW TOTAL-LENGTH RESULT)
             (DYNAMIC-EXTENT OVERFLOW TOTAL-LENGTH RESULT))
    (SETF *PREV-BYTE* (LDB # B))
    (WRITE-STUFFED (DEPOSIT-FIELD # # RESULT) S) ..)
Note: DYNAMIC-EXTENT declaration not implemented.

Converted WRITE-BITS.
Compiling DEFUN WRITE-BITS: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN WRITE-BITS
  (LDB (BYTE OVERFLOW 0) B)
==>
  (KERNEL:%LDB OVERFLOW 0 B)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

  (DEPOSIT-FIELD B (BYTE N 0) (ASH *PREV-BYTE* N))
==>
  (KERNEL:%DEPOSIT-FIELD B N 0 (ASH *PREV-BYTE* N))
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (SIGNED-BYTE 32).

  (INCF *PREV-LENGTH* N)
--> LET* 
==>
  (+ *PREV-LENGTH* N)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.

  (DEPOSIT-FIELD (LDB (BYTE # OVERFLOW) B)
                 (BYTE (MINUS 8 *PREV-LENGTH*) 0)
                 RESULT)
--> KERNEL:%DEPOSIT-FIELD LET ASH LDB 
==>
  (KERNEL:%LDB C::SIZE 0 -1)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

  (ASH *PREV-BYTE* N)
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 INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

  (INCF *PREV-LENGTH* N)
--> LET* 
==>
  (+ *PREV-LENGTH* N)
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 result is a NUMBER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a NUMBER, not a (SIGNED-BYTE 32).
      etc.

  (ASH *PREV-BYTE* (MINUS 8 *PREV-LENGTH*))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a FIXNUM.
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      etc.

  (DEPOSIT-FIELD (LDB (BYTE # OVERFLOW) B)
                 (BYTE (MINUS 8 *PREV-LENGTH*) 0)
                 RESULT)
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::NEW C::MASK)
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a UNSIGNED-BYTE, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      etc.

--> KERNEL:%DEPOSIT-FIELD LET LOGIOR LOGAND 
==>
  (LOGNOT C::MASK)
Note: Forced to do full call.
      Unable to do inline (signed-byte 32) arithmetic (cost 1) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a (INTEGER * -1), not a FIXNUM.

--> KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::INT (LOGNOT C::MASK))
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a (INTEGER * -1), not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> KERNEL:%DEPOSIT-FIELD LET 
==>
  (LOGIOR (LOGAND C::NEW C::MASK) (LOGAND C::INT (LOGNOT C::MASK)))
Note: Forced to do static-function Two-arg-ior (cost 53).
      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.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The second argument is a INTEGER, not a (SIGNED-BYTE 32).
      etc.


File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN ENCODE-BLOCK
  (LET* ((EHUFSI-DC #)
         (EHUFCO-DC #)
         (EHUFSI-AC #)
         (EHUFCO-AC #)
         (NEWPRED #) ..))
Note: DYNAMIC-EXTENT declaration not implemented.

  (WRITE-BITS (SVREF EHUFCO-DC DCPOS) (SVREF EHUFSI-DC DCPOS) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
==>
  (LET ((B #) (N #))
    (DECLARE (TYPE FIXNUM B N) (DYNAMIC-EXTENT B N))
    (COND (#) (# #) (T # #)))
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN 
==>
  (LET* ((RESULT #) (TOTAL-LENGTH #) (OVERFLOW #))
    (DECLARE (TYPE FIXNUM OVERFLOW TOTAL-LENGTH RESULT)
             (DYNAMIC-EXTENT OVERFLOW TOTAL-LENGTH RESULT))
    (SETF *PREV-BYTE* (LDB # B))
    (WRITE-STUFFED (DEPOSIT-FIELD # # RESULT) S) ..)
Note: DYNAMIC-EXTENT declaration not implemented.

Converted ENCODE-BLOCK.

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN ENCODE-BLOCK
  (WRITE-BITS (SVREF BLOCK K) SSSS S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
==>
  (LET ((B #) (N #))
    (DECLARE (TYPE FIXNUM B N) (DYNAMIC-EXTENT B N))
    (COND (#) (# #) (T # #)))
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN 
==>
  (LET* ((RESULT #) (TOTAL-LENGTH #) (OVERFLOW #))
    (DECLARE (TYPE FIXNUM OVERFLOW TOTAL-LENGTH RESULT)
             (DYNAMIC-EXTENT OVERFLOW TOTAL-LENGTH RESULT))
    (SETF *PREV-BYTE* (LDB # B))
    (WRITE-STUFFED (DEPOSIT-FIELD # # RESULT) S) ..)
Note: DYNAMIC-EXTENT declaration not implemented.

  (WRITE-BITS (SVREF EHUFCO-AC RS) (SVREF EHUFSI-AC RS) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
==>
  (LET ((B #) (N #))
    (DECLARE (TYPE FIXNUM B N) (DYNAMIC-EXTENT B N))
    (COND (#) (# #) (T # #)))
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN 
==>
  (LET* ((RESULT #) (TOTAL-LENGTH #) (OVERFLOW #))
    (DECLARE (TYPE FIXNUM OVERFLOW TOTAL-LENGTH RESULT)
             (DYNAMIC-EXTENT OVERFLOW TOTAL-LENGTH RESULT))
    (SETF *PREV-BYTE* (LDB # B))
    (WRITE-STUFFED (DEPOSIT-FIELD # # RESULT) S) ..)
Note: DYNAMIC-EXTENT declaration not implemented.

  (WRITE-BITS (SVREF EHUFCO-AC 240) (SVREF EHUFSI-AC 240) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
==>
  (LET ((B #) (N #))
    (DECLARE (TYPE FIXNUM B N) (DYNAMIC-EXTENT B N))
    (COND (#) (# #) (T # #)))
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN 
==>
  (LET* ((RESULT #) (TOTAL-LENGTH #) (OVERFLOW #))
    (DECLARE (TYPE FIXNUM OVERFLOW TOTAL-LENGTH RESULT)
             (DYNAMIC-EXTENT OVERFLOW TOTAL-LENGTH RESULT))
    (SETF *PREV-BYTE* (LDB # B))
    (WRITE-STUFFED (DEPOSIT-FIELD # # RESULT) S) ..)
Note: DYNAMIC-EXTENT declaration not implemented.

  (WRITE-BITS (SVREF EHUFCO-AC 0) (SVREF EHUFSI-AC 0) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
==>
  (LET ((B #) (N #))
    (DECLARE (TYPE FIXNUM B N) (DYNAMIC-EXTENT B N))
    (COND (#) (# #) (T # #)))
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN 
==>
  (LET* ((RESULT #) (TOTAL-LENGTH #) (OVERFLOW #))
    (DECLARE (TYPE FIXNUM OVERFLOW TOTAL-LENGTH RESULT)
             (DYNAMIC-EXTENT OVERFLOW TOTAL-LENGTH RESULT))
    (SETF *PREV-BYTE* (LDB # B))
    (WRITE-STUFFED (DEPOSIT-FIELD # # RESULT) S) ..)
Note: DYNAMIC-EXTENT declaration not implemented.

  (WRITE-BITS DIFF (CSIZE DIFF) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
==>
  (LET ((B #) (N #))
    (DECLARE (TYPE FIXNUM B N) (DYNAMIC-EXTENT B N))
    (COND (#) (# #) (T # #)))
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN 
==>
  (LET* ((RESULT #) (TOTAL-LENGTH #) (OVERFLOW #))
    (DECLARE (TYPE FIXNUM OVERFLOW TOTAL-LENGTH RESULT)
             (DYNAMIC-EXTENT OVERFLOW TOTAL-LENGTH RESULT))
    (SETF *PREV-BYTE* (LDB # B))
    (WRITE-STUFFED (DEPOSIT-FIELD # # RESULT) S) ..)
Note: DYNAMIC-EXTENT declaration not implemented.

  (WRITE-BITS (1- DIFF) (CSIZE DIFF) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
==>
  (LET ((B #) (N #))
    (DECLARE (TYPE FIXNUM B N) (DYNAMIC-EXTENT B N))
    (COND (#) (# #) (T # #)))
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN 
==>
  (LET* ((RESULT #) (TOTAL-LENGTH #) (OVERFLOW #))
    (DECLARE (TYPE FIXNUM OVERFLOW TOTAL-LENGTH RESULT)
             (DYNAMIC-EXTENT OVERFLOW TOTAL-LENGTH RESULT))
    (SETF *PREV-BYTE* (LDB # B))
    (WRITE-STUFFED (DEPOSIT-FIELD # # RESULT) S) ..)
Note: DYNAMIC-EXTENT declaration not implemented.

Compiling DEFUN ENCODE-BLOCK: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN ENCODE-BLOCK
  (WRITE-BITS (1- DIFF) (CSIZE DIFF) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* SETF SETQ LDB 
==>
  (KERNEL:%LDB OVERFLOW 0 B)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN SETF SETQ DEPOSIT-FIELD 
==>
  (KERNEL:%DEPOSIT-FIELD B N 0 (ASH *PREV-BYTE* N))
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.

  (WRITE-BITS DIFF (CSIZE DIFF) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* SETF SETQ LDB 
==>
  (KERNEL:%LDB OVERFLOW 0 B)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN SETF SETQ DEPOSIT-FIELD 
==>
  (KERNEL:%DEPOSIT-FIELD B N 0 (ASH *PREV-BYTE* N))
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.

  (ZEROP (SVREF BLOCK K))
==>
  (= (SVREF BLOCK K) 0)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
Note: Unable to open code because:
      Operands might not be the same type.

  (WRITE-BITS (SVREF EHUFCO-AC 0) (SVREF EHUFSI-AC 0) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* SETF SETQ LDB 
==>
  (KERNEL:%LDB OVERFLOW 0 B)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN SETF SETQ DEPOSIT-FIELD 
==>
  (KERNEL:%DEPOSIT-FIELD B N 0 (ASH *PREV-BYTE* N))
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.

  (MINUSP (SVREF BLOCK K))
==>
  (< (SVREF BLOCK K) 0)
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a INTEGER.

  (DECF (SVREF BLOCK K) 1)
--> LET* 
==>
  (- (SVREF #:G11 #:G10) 1)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.

  (WRITE-BITS (SVREF BLOCK K) SSSS S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* SETF SETQ LDB 
==>
  (KERNEL:%LDB OVERFLOW 0 B)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN SETF SETQ DEPOSIT-FIELD 
==>
  (KERNEL:%DEPOSIT-FIELD B N 0 (ASH *PREV-BYTE* N))
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.

  (WRITE-BITS (SVREF EHUFCO-AC RS) (SVREF EHUFSI-AC RS) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* SETF SETQ LDB 
==>
  (KERNEL:%LDB OVERFLOW 0 B)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN SETF SETQ DEPOSIT-FIELD 
==>
  (KERNEL:%DEPOSIT-FIELD B N 0 (ASH *PREV-BYTE* N))
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.

  (WRITE-BITS (SVREF EHUFCO-AC 240) (SVREF EHUFSI-AC 240) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* SETF SETQ LDB 
==>
  (KERNEL:%LDB OVERFLOW 0 B)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN SETF SETQ DEPOSIT-FIELD 
==>
  (KERNEL:%DEPOSIT-FIELD B N 0 (ASH *PREV-BYTE* N))
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.

  (WRITE-BITS (SVREF EHUFCO-DC DCPOS) (SVREF EHUFSI-DC DCPOS) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* SETF SETQ LDB 
==>
  (KERNEL:%LDB OVERFLOW 0 B)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN SETF SETQ DEPOSIT-FIELD 
==>
  (KERNEL:%DEPOSIT-FIELD B N 0 (ASH *PREV-BYTE* N))
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET ASH LDB 
==>
  (KERNEL:%LDB C::SIZE 0 -1)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

  (WRITE-BITS (SVREF EHUFCO-AC 240) (SVREF EHUFSI-AC 240) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET ASH LDB 
==>
  (KERNEL:%LDB C::SIZE 0 -1)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

  (WRITE-BITS (SVREF EHUFCO-AC RS) (SVREF EHUFSI-AC RS) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET ASH LDB 
==>
  (KERNEL:%LDB C::SIZE 0 -1)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

  (WRITE-BITS (SVREF BLOCK K) SSSS S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET ASH LDB 
==>
  (KERNEL:%LDB C::SIZE 0 -1)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

  (WRITE-BITS (SVREF EHUFCO-AC 0) (SVREF EHUFSI-AC 0) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET ASH LDB 
==>
  (KERNEL:%LDB C::SIZE 0 -1)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

  (WRITE-BITS DIFF (CSIZE DIFF) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET ASH LDB 
==>
  (KERNEL:%LDB C::SIZE 0 -1)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

  (WRITE-BITS (1- DIFF) (CSIZE DIFF) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET ASH LDB 
==>
  (KERNEL:%LDB C::SIZE 0 -1)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

  (WRITE-BITS (SVREF EHUFCO-DC DCPOS) (SVREF EHUFSI-DC DCPOS) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN SETF SETQ DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD 
==>
  (ASH *PREV-BYTE* N)
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 INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
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 result is a NUMBER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a NUMBER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* 
==>
  (ASH *PREV-BYTE* (MINUS 8 *PREV-LENGTH*))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a FIXNUM.
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::NEW C::MASK)
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a UNSIGNED-BYTE, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR LOGAND 
==>
  (LOGNOT C::MASK)
Note: Forced to do full call.
      Unable to do inline (signed-byte 32) arithmetic (cost 1) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a (INTEGER * -1), not a FIXNUM.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::INT (LOGNOT C::MASK))
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a (INTEGER * -1), not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET 
==>
  (LOGIOR (LOGAND C::NEW C::MASK) (LOGAND C::INT (LOGNOT C::MASK)))
Note: Forced to do static-function Two-arg-ior (cost 53).
      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.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The second argument is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

  (WRITE-BITS (1- DIFF) (CSIZE DIFF) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN SETF SETQ DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD 
==>
  (ASH *PREV-BYTE* N)
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 INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
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 result is a NUMBER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a NUMBER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* 
==>
  (ASH *PREV-BYTE* (MINUS 8 *PREV-LENGTH*))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a FIXNUM.
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::NEW C::MASK)
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a UNSIGNED-BYTE, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR LOGAND 
==>
  (LOGNOT C::MASK)
Note: Forced to do full call.
      Unable to do inline (signed-byte 32) arithmetic (cost 1) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a (INTEGER * -1), not a FIXNUM.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::INT (LOGNOT C::MASK))
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a (INTEGER * -1), not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET 
==>
  (LOGIOR (LOGAND C::NEW C::MASK) (LOGAND C::INT (LOGNOT C::MASK)))
Note: Forced to do static-function Two-arg-ior (cost 53).
      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.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The second argument is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

  (WRITE-BITS DIFF (CSIZE DIFF) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN SETF SETQ DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD 
==>
  (ASH *PREV-BYTE* N)
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 INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
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 result is a NUMBER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a NUMBER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* 
==>
  (ASH *PREV-BYTE* (MINUS 8 *PREV-LENGTH*))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a FIXNUM.
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::NEW C::MASK)
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a UNSIGNED-BYTE, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR LOGAND 
==>
  (LOGNOT C::MASK)
Note: Forced to do full call.
      Unable to do inline (signed-byte 32) arithmetic (cost 1) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a (INTEGER * -1), not a FIXNUM.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::INT (LOGNOT C::MASK))
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a (INTEGER * -1), not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET 
==>
  (LOGIOR (LOGAND C::NEW C::MASK) (LOGAND C::INT (LOGNOT C::MASK)))
Note: Forced to do static-function Two-arg-ior (cost 53).
      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.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The second argument is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

  (WRITE-BITS (SVREF EHUFCO-AC 0) (SVREF EHUFSI-AC 0) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN SETF SETQ DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD 
==>
  (ASH *PREV-BYTE* N)
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 INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
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 result is a NUMBER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a NUMBER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* 
==>
  (ASH *PREV-BYTE* (MINUS 8 *PREV-LENGTH*))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a FIXNUM.
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::NEW C::MASK)
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a UNSIGNED-BYTE, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR LOGAND 
==>
  (LOGNOT C::MASK)
Note: Forced to do full call.
      Unable to do inline (signed-byte 32) arithmetic (cost 1) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a (INTEGER * -1), not a FIXNUM.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::INT (LOGNOT C::MASK))
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a (INTEGER * -1), not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET 
==>
  (LOGIOR (LOGAND C::NEW C::MASK) (LOGAND C::INT (LOGNOT C::MASK)))
Note: Forced to do static-function Two-arg-ior (cost 53).
      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.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The second argument is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

  (WRITE-BITS (SVREF EHUFCO-AC 240) (SVREF EHUFSI-AC 240) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN SETF SETQ DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD 
==>
  (ASH *PREV-BYTE* N)
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 INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
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 result is a NUMBER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a NUMBER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* 
==>
  (ASH *PREV-BYTE* (MINUS 8 *PREV-LENGTH*))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a FIXNUM.
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::NEW C::MASK)
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a UNSIGNED-BYTE, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR LOGAND 
==>
  (LOGNOT C::MASK)
Note: Forced to do full call.
      Unable to do inline (signed-byte 32) arithmetic (cost 1) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a (INTEGER * -1), not a FIXNUM.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::INT (LOGNOT C::MASK))
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a (INTEGER * -1), not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET 
==>
  (LOGIOR (LOGAND C::NEW C::MASK) (LOGAND C::INT (LOGNOT C::MASK)))
Note: Forced to do static-function Two-arg-ior (cost 53).
      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.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The second argument is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

  (WRITE-BITS (SVREF EHUFCO-AC RS) (SVREF EHUFSI-AC RS) S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN SETF SETQ DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD 
==>
  (ASH *PREV-BYTE* N)
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 INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
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 result is a NUMBER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a NUMBER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* 
==>
  (ASH *PREV-BYTE* (MINUS 8 *PREV-LENGTH*))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a FIXNUM.
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::NEW C::MASK)
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a UNSIGNED-BYTE, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR LOGAND 
==>
  (LOGNOT C::MASK)
Note: Forced to do full call.
      Unable to do inline (signed-byte 32) arithmetic (cost 1) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a (INTEGER * -1), not a FIXNUM.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::INT (LOGNOT C::MASK))
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a (INTEGER * -1), not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET 
==>
  (LOGIOR (LOGAND C::NEW C::MASK) (LOGAND C::INT (LOGNOT C::MASK)))
Note: Forced to do static-function Two-arg-ior (cost 53).
      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.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The second argument is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

  (MINUSP (SVREF BLOCK K))
==>
  (< (SVREF BLOCK K) 0)
Note: Forced to do GENERIC-< (cost 10).
      Unable to do inline fixnum comparison (cost 3) because:
      The first argument is a REAL, not a FIXNUM.
      Unable to do inline fixnum comparison (cost 4) because:
      The first argument is a REAL, not a FIXNUM.
      etc.

  (DECF (SVREF BLOCK K) 1)
--> LET* 
==>
  (- (SVREF #:G11 #:G10) 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 NUMBER, not a FIXNUM.
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a NUMBER, not a FIXNUM.
      The result is a NUMBER, not a FIXNUM.
      etc.

  (WRITE-BITS (SVREF BLOCK K) SSSS S)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN SETF SETQ DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD 
==>
  (ASH *PREV-BYTE* N)
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 INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
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 result is a NUMBER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a NUMBER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* 
==>
  (ASH *PREV-BYTE* (MINUS 8 *PREV-LENGTH*))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a FIXNUM.
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::NEW C::MASK)
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a UNSIGNED-BYTE, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR LOGAND 
==>
  (LOGNOT C::MASK)
Note: Forced to do full call.
      Unable to do inline (signed-byte 32) arithmetic (cost 1) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a (INTEGER * -1), not a FIXNUM.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::INT (LOGNOT C::MASK))
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a (INTEGER * -1), not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET 
--> IF COND IF PROGN LET* WRITE-STUFFED DEPOSIT-FIELD 
--> KERNEL:%DEPOSIT-FIELD LET 
==>
  (LOGIOR (LOGAND C::NEW C::MASK) (LOGAND C::INT (LOGNOT C::MASK)))
Note: Forced to do static-function Two-arg-ior (cost 53).
      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.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The second argument is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

Converted WRITE-QUANTIZATION-TABLES.
Compiling DEFUN WRITE-QUANTIZATION-TABLES: 
Converted WRITE-HUFFMAN-TABLES.
Compiling DEFUN WRITE-HUFFMAN-TABLES: 
Converted WRITE-HUFFTABLE.
Compiling DEFUN WRITE-HUFFTABLE: 
Converted WRITE-MARKER.
Compiling DEFUN WRITE-MARKER: 
Converted PREPARE-JFIF-STREAM.
Compiling DEFUN PREPARE-JFIF-STREAM: 
Converted BUILD-UNIVERSAL-TABLES.
Compiling DEFUN BUILD-UNIVERSAL-TABLES: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN BUILD-UNIVERSAL-TABLES
  (> J (SVREF BITS (1- I)))
Note: Unable to optimize due to type uncertainty:
      The second argument is a REAL, not a INTEGER.

  (/= (SVREF HUFFSIZE K) SI)
--> IF 
==>
  (= (SVREF HUFFSIZE K) SI)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
Note: Unable to open code because:
      Operands might not be the same type.

  (ZEROP (SVREF HUFFSIZE K))
==>
  (= (SVREF HUFFSIZE K) 0)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
Note: Unable to open code because:
      Operands might not be the same type.

  (= (SVREF HUFFSIZE K) SI)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
Note: Unable to open code because:
      Operands might not be the same type.

  (> J (SVREF BITS (1- I)))
Note: Forced to do GENERIC-> (cost 10).
      Unable to do inline fixnum comparison (cost 4) because:
      The second argument is a REAL, not a FIXNUM.

Converted BUILD-TABLES.
Compiling DEFUN BUILD-TABLES: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN ENCODE-IMAGE-STREAM
  (MULTIPLE-VALUE-BIND
      (XLIM YLIM)
      (IF (= NCOMP 3)
          (COLORSPACE-CONVERT IMAGE YUV DX DY ...)
          (CROP-IMAGE IMAGE YUV DX DY ...)) ..)
--> MULTIPLE-VALUE-CALL 
==>
  #'(LAMBDA (&OPTIONAL XLIM YLIM &REST #:G28)
      (DECLARE (IGNORE #:G28))
      (DECLARE (TYPE FIXNUM XLIM YLIM) (DYNAMIC-EXTENT XLIM YLIM))
      (LOOP FOR COMP ACROSS YUV ...))
Note: DYNAMIC-EXTENT declaration not implemented.

  (ENCODE-BLOCK (ZIGZAG (SVREF SAMPLED-BUF POS)) HUFFTABS (SVREF PREDS CN)
   OUT-STREAM)
--> BLOCK 
==>
  (LET* ((EHUFSI-DC #)
         (EHUFCO-DC #)
         (EHUFSI-AC #)
         (EHUFCO-AC #)
         (NEWPRED #) ..))
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY 
==>
  (LET ((B #) (N #))
    (DECLARE (TYPE FIXNUM B N) (DYNAMIC-EXTENT B N))
    (COND (#) (# #) (T # #)))
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN 
==>
  (LET* ((RESULT #) (TOTAL-LENGTH #) (OVERFLOW #))
    (DECLARE (TYPE FIXNUM OVERFLOW TOTAL-LENGTH RESULT)
             (DYNAMIC-EXTENT OVERFLOW TOTAL-LENGTH RESULT))
    (SETF *PREV-BYTE* (LDB # B))
    (WRITE-STUFFED (DEPOSIT-FIELD # # RESULT) S) ..)
Note: DYNAMIC-EXTENT declaration not implemented.

Converted ENCODE-IMAGE-STREAM.

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN ENCODE-IMAGE-STREAM
  (ENCODE-BLOCK (ZIGZAG (SVREF SAMPLED-BUF POS)) HUFFTABS (SVREF PREDS CN)
   OUT-STREAM)
--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY 
==>
  (LET ((B #) (N #))
    (DECLARE (TYPE FIXNUM B N) (DYNAMIC-EXTENT B N))
    (COND (#) (# #) (T # #)))
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN 
==>
  (LET* ((RESULT #) (TOTAL-LENGTH #) (OVERFLOW #))
    (DECLARE (TYPE FIXNUM OVERFLOW TOTAL-LENGTH RESULT)
             (DYNAMIC-EXTENT OVERFLOW TOTAL-LENGTH RESULT))
    (SETF *PREV-BYTE* (LDB # B))
    (WRITE-STUFFED (DEPOSIT-FIELD # # RESULT) S) ..)
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY 
==>
  (LET ((B #) (N #))
    (DECLARE (TYPE FIXNUM B N) (DYNAMIC-EXTENT B N))
    (COND (#) (# #) (T # #)))
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN 
==>
  (LET* ((RESULT #) (TOTAL-LENGTH #) (OVERFLOW #))
    (DECLARE (TYPE FIXNUM OVERFLOW TOTAL-LENGTH RESULT)
             (DYNAMIC-EXTENT OVERFLOW TOTAL-LENGTH RESULT))
    (SETF *PREV-BYTE* (LDB # B))
    (WRITE-STUFFED (DEPOSIT-FIELD # # RESULT) S) ..)
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LOOP BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN WRITE-BITS BLOCK LOOP 
--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
==>
  (LET ((B #) (N #))
    (DECLARE (TYPE FIXNUM B N) (DYNAMIC-EXTENT B N))
    (COND (#) (# #) (T # #)))
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LOOP BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN WRITE-BITS BLOCK LOOP 
--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF 
--> PROGN 
==>
  (LET* ((RESULT #) (TOTAL-LENGTH #) (OVERFLOW #))
    (DECLARE (TYPE FIXNUM OVERFLOW TOTAL-LENGTH RESULT)
             (DYNAMIC-EXTENT OVERFLOW TOTAL-LENGTH RESULT))
    (SETF *PREV-BYTE* (LDB # B))
    (WRITE-STUFFED (DEPOSIT-FIELD # # RESULT) S) ..)
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF IF 
--> PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY 
==>
  (LET ((B #) (N #))
    (DECLARE (TYPE FIXNUM B N) (DYNAMIC-EXTENT B N))
    (COND (#) (# #) (T # #)))
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF IF 
--> PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN 
==>
  (LET* ((RESULT #) (TOTAL-LENGTH #) (OVERFLOW #))
    (DECLARE (TYPE FIXNUM OVERFLOW TOTAL-LENGTH RESULT)
             (DYNAMIC-EXTENT OVERFLOW TOTAL-LENGTH RESULT))
    (SETF *PREV-BYTE* (LDB # B))
    (WRITE-STUFFED (DEPOSIT-FIELD # # RESULT) S) ..)
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LET* COND IF COND IF PROGN WRITE-BITS BLOCK LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
==>
  (LET ((B #) (N #))
    (DECLARE (TYPE FIXNUM B N) (DYNAMIC-EXTENT B N))
    (COND (#) (# #) (T # #)))
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LET* COND IF COND IF PROGN WRITE-BITS BLOCK LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF PROGN 
==>
  (LET* ((RESULT #) (TOTAL-LENGTH #) (OVERFLOW #))
    (DECLARE (TYPE FIXNUM OVERFLOW TOTAL-LENGTH RESULT)
             (DYNAMIC-EXTENT OVERFLOW TOTAL-LENGTH RESULT))
    (SETF *PREV-BYTE* (LDB # B))
    (WRITE-STUFFED (DEPOSIT-FIELD # # RESULT) S) ..)
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LET* COND IF PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK 
--> ANSI-LOOP::LOOP-BODY TAGBODY 
==>
  (LET ((B #) (N #))
    (DECLARE (TYPE FIXNUM B N) (DYNAMIC-EXTENT B N))
    (COND (#) (# #) (T # #)))
Note: DYNAMIC-EXTENT declaration not implemented.

--> BLOCK LET* COND IF PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK 
--> ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF PROGN 
==>
  (LET* ((RESULT #) (TOTAL-LENGTH #) (OVERFLOW #))
    (DECLARE (TYPE FIXNUM OVERFLOW TOTAL-LENGTH RESULT)
             (DYNAMIC-EXTENT OVERFLOW TOTAL-LENGTH RESULT))
    (SETF *PREV-BYTE* (LDB # B))
    (WRITE-STUFFED (DEPOSIT-FIELD # # RESULT) S) ..)
Note: DYNAMIC-EXTENT declaration not implemented.

Compiling DEFUN ENCODE-IMAGE-STREAM: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN ENCODE-IMAGE-STREAM
  (COLORSPACE-CONVERT IMAGE YUV DX DY ...)
--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ * * 
==>
  (* W YD)
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a (INTEGER -288230375614840832 288230376151711744), not a (UNSIGNED-BYTE
                                                                               32).

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ * 
==>
  (* (* W YD) 3)
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a (INTEGER -288230375614840832 288230376151711744), not a (UNSIGNED-BYTE
                                                                                       32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET 
--> LET LET LET LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ PLUS THE + THE MUL THE 
==>
  (* (THE FIXNUM XD) (THE FIXNUM 3))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET 
--> LET LET LET LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN 
--> SETF LET* MULTIPLE-VALUE-BIND LET MINUS THE - THE ASH + + 
==>
  (+ (SVREF *CTAB* (PLUS R R-Y-OFF)) (SVREF *CTAB* (PLUS G G-Y-OFF)))
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a RATIONAL.
      The second argument is a NUMBER, not a FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
      The second argument is a NUMBER, not a RATIONAL.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET 
--> LET LET LET LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN 
--> SETF LET* MULTIPLE-VALUE-BIND LET MINUS THE - THE ASH + 
==>
  (+ (+ (SVREF *CTAB* #) (SVREF *CTAB* #)) (SVREF *CTAB* (PLUS B B-Y-OFF)))
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a RATIONAL.
      The second argument is a NUMBER, not a FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
      The second argument is a NUMBER, not a RATIONAL.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET 
--> LET LET LET LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN 
--> SETF LET* MULTIPLE-VALUE-BIND LET MINUS THE - THE ASH + + 
==>
  (+ (SVREF *CTAB* (PLUS R R-U-OFF)) (SVREF *CTAB* (PLUS G G-U-OFF)))
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a RATIONAL.
      The second argument is a NUMBER, not a FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
      The second argument is a NUMBER, not a RATIONAL.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET 
--> LET LET LET LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN 
--> SETF LET* MULTIPLE-VALUE-BIND LET MINUS THE - THE ASH + 
==>
  (+ (+ (SVREF *CTAB* #) (SVREF *CTAB* #)) (SVREF *CTAB* (PLUS B B-U-OFF)))
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a RATIONAL.
      The second argument is a NUMBER, not a FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
      The second argument is a NUMBER, not a RATIONAL.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET 
--> LET LET LET LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN 
--> SETF LET* MULTIPLE-VALUE-BIND LET MINUS THE - THE ASH + + 
==>
  (+ (SVREF *CTAB* (PLUS R R-V-OFF)) (SVREF *CTAB* (PLUS G G-V-OFF)))
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a RATIONAL.
      The second argument is a NUMBER, not a FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
      The second argument is a NUMBER, not a RATIONAL.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET 
--> LET LET LET LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN 
--> SETF LET* MULTIPLE-VALUE-BIND LET MINUS THE - THE ASH + 
==>
  (+ (+ (SVREF *CTAB* #) (SVREF *CTAB* #)) (SVREF *CTAB* (PLUS B B-V-OFF)))
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a RATIONAL.
      The second argument is a NUMBER, not a FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
      The second argument is a NUMBER, not a RATIONAL.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
      The second argument is a NUMBER, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a SINGLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

  (ENCODE-BLOCK (ZIGZAG (SVREF SAMPLED-BUF POS)) HUFFTABS (SVREF PREDS CN)
   OUT-STREAM)
--> BLOCK LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* SETF SETQ LDB 
==>
  (KERNEL:%LDB OVERFLOW 0 B)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

--> BLOCK LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF COND IF PROGN SETF SETQ 
--> DEPOSIT-FIELD 
==>
  (KERNEL:%DEPOSIT-FIELD B N 0 (ASH *PREV-BYTE* N))
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.

--> BLOCK LET* COND IF PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK 
--> ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF PROGN LET* 
--> SETF SETQ LDB 
==>
  (KERNEL:%LDB OVERFLOW 0 B)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

--> BLOCK LET* COND IF PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK 
--> ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF COND IF PROGN 
--> SETF SETQ DEPOSIT-FIELD 
==>
  (KERNEL:%DEPOSIT-FIELD B N 0 (ASH *PREV-BYTE* N))
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LET* COND IF PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK 
--> ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF COND IF PROGN 
--> INCF LET* 
==>
  (+ *PREV-LENGTH* N)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.

--> BLOCK LET* COND IF COND IF PROGN WRITE-BITS BLOCK LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF PROGN 
--> LET* SETF SETQ LDB 
==>
  (KERNEL:%LDB OVERFLOW 0 B)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

--> BLOCK LET* COND IF COND IF PROGN WRITE-BITS BLOCK LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF COND IF 
--> PROGN SETF SETQ DEPOSIT-FIELD 
==>
  (KERNEL:%DEPOSIT-FIELD B N 0 (ASH *PREV-BYTE* N))
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LET* COND IF COND IF PROGN WRITE-BITS BLOCK LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF COND IF 
--> PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF ZEROP 
==>
  (= (SVREF BLOCK K) 0)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
Note: Unable to open code because:
      Operands might not be the same type.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF IF 
--> PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* SETF SETQ LDB 
==>
  (KERNEL:%LDB OVERFLOW 0 B)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF IF 
--> PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF COND IF PROGN SETF SETQ 
--> DEPOSIT-FIELD 
==>
  (KERNEL:%DEPOSIT-FIELD B N 0 (ASH *PREV-BYTE* N))
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF IF 
--> PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WHEN COND IF MINUSP 
==>
  (< (SVREF BLOCK K) 0)
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a INTEGER.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WHEN COND IF PROGN DECF LET* 
==>
  (- (SVREF #:G134 #:G133) 1)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* SETF SETQ LDB 
==>
  (KERNEL:%LDB OVERFLOW 0 B)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF COND IF PROGN SETF SETQ 
--> DEPOSIT-FIELD 
==>
  (KERNEL:%DEPOSIT-FIELD B N 0 (ASH *PREV-BYTE* N))
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* SETF SETQ LDB 
==>
  (KERNEL:%LDB OVERFLOW 0 B)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF COND IF PROGN SETF SETQ 
--> DEPOSIT-FIELD 
==>
  (KERNEL:%DEPOSIT-FIELD B N 0 (ASH *PREV-BYTE* N))
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LOOP BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN WRITE-BITS BLOCK LOOP 
--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF 
--> PROGN LET* SETF SETQ LDB 
==>
  (KERNEL:%LDB OVERFLOW 0 B)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LOOP BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN WRITE-BITS BLOCK LOOP 
--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF 
--> COND IF PROGN SETF SETQ DEPOSIT-FIELD 
==>
  (KERNEL:%DEPOSIT-FIELD B N 0 (ASH *PREV-BYTE* N))
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LOOP BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN WRITE-BITS BLOCK LOOP 
--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF 
--> COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.

  (CRUNCH SAMPLED-BUF POS Q-TAB)
--> BLOCK LLM-DCT BLOCK LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> PROGN LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN SETF SETQ 
--> MUL THE 
==>
  (* (THE FIXNUM (PLUS TMP12 TMP13)) (THE FIXNUM FIX-0-541196100))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

--> BLOCK LLM-DCT BLOCK LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> PROGN LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN SETF LET* 
--> MULTIPLE-VALUE-BIND LET DESCALE PLUS THE + THE MUL THE 
==>
  (* (THE FIXNUM TMP13) (THE FIXNUM FIX-0-765366865))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

--> BLOCK LLM-DCT BLOCK LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> PROGN LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN SETF SETQ 
--> MUL THE 
==>
  (* (THE FIXNUM (PLUS Z3 Z4)) (THE FIXNUM FIX-1-175875602))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP4) (THE FIXNUM FIX-0-298631336))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP5) (THE FIXNUM FIX-2-053119869))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP6) (THE FIXNUM FIX-3-072711026))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP7) (THE FIXNUM FIX-1-501321110))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM (PLUS TMP12 TMP13)) (THE FIXNUM FIX-0-541196100))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

--> BLOCK LLM-DCT BLOCK LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> PROGN LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN SETF 
--> COMMON-LISP::%SVSET COMMON-LISP::%ASET DESCALE PLUS THE + THE MUL 
--> THE 
==>
  (* (THE FIXNUM TMP13) (THE FIXNUM FIX-0-765366865))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

--> BLOCK LLM-DCT BLOCK LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> PROGN LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN SETF SETQ 
--> MUL THE 
==>
  (* (THE FIXNUM (PLUS Z3 Z4)) (THE FIXNUM FIX-1-175875602))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP4) (THE FIXNUM FIX-0-298631336))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP5) (THE FIXNUM FIX-2-053119869))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP6) (THE FIXNUM FIX-3-072711026))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP7) (THE FIXNUM FIX-1-501321110))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (SUBSAMPLE COMP SAMPLED-BUF H V ...)
--> BLOCK LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ 
--> SETQ SVREF AREF PLUS THE + THE MUL THE 
==>
  (* (THE FIXNUM BY) (THE FIXNUM H))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a (INTEGER -536870906 536870911), not a (UNSIGNED-BYTE
                                                                     32).
      The second argument is a (INTEGER -536870905 536870911), not a (UNSIGNED-BYTE
                                                                      32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL (REM (ASH YLIM -3) V) H)
--> THE 
==>
  (* (THE FIXNUM (REM # V)) (THE FIXNUM H))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a (INTEGER -536870910 536870910), not a (UNSIGNED-BYTE
                                                                     32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL Y H)
--> THE 
==>
  (* (THE FIXNUM Y) (THE FIXNUM H))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a (INTEGER -536870906 536870910), not a (UNSIGNED-BYTE
                                                                     32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL HT WD)
--> THE 
==>
  (* (THE FIXNUM HT) (THE FIXNUM WD))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (LENGTH SAMPLING)
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR VECTOR CONS NULL), not a (SIMPLE-ARRAY * (*)).
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR VECTOR CONS NULL), not a VECTOR.

  (LENGTH Q-TABS)
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR VECTOR CONS NULL), not a (SIMPLE-ARRAY * (*)).
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR VECTOR CONS NULL), not a VECTOR.

  (> (COUNT-RELATION SAMPLING) 10)
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a INTEGER.

  (LENGTH Q-TABS)
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR CONS NULL VECTOR), not a (SIMPLE-ARRAY * (*)).
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR CONS NULL VECTOR), not a VECTOR.
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR CONS NULL VECTOR), not a (SIMPLE-ARRAY * (*)).
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR CONS NULL VECTOR), not a VECTOR.

  (LOOP FOR ENTRY ACROSS Q-TABS ...)
--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY SETQ 
==>
  (LENGTH #:G0)
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a (SIMPLE-ARRAY * (*)).
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a VECTOR.

--> LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY SETQ 
==>
  (LENGTH #:G20)
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a (SIMPLE-ARRAY * (*)).
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a VECTOR.

  (ZEROP *PREV-LENGTH*)
==>
  (= *PREV-LENGTH* 0)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a FLOAT.
Note: Unable to open code because:
      Operands might not be the same type.

  (LOOP FOR ENTRY IN SAMPLING ...)
--> LET ANSI-LOOP::WITH-MINIMAX-VALUE LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY ANSI-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN COND IF 
--> OR LET IF OR > IF 
==>
  (> #:G181 #:G180)
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a SINGLE-FLOAT.
      The second argument is a REAL, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a DOUBLE-FLOAT.
      The second argument is a REAL, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a FLOAT.
      The second argument is a REAL, not a RATIONAL.
Note: Unable to 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 FLOAT.
      The second argument is a REAL, not a FLOAT.

==>
  (> #:G186 #:G185)
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a SINGLE-FLOAT.
      The second argument is a REAL, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a DOUBLE-FLOAT.
      The second argument is a REAL, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a FLOAT.
      The second argument is a REAL, not a RATIONAL.
Note: Unable to 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 FLOAT.
      The second argument is a REAL, not a FLOAT.

  (DEPOSIT-FIELD 255
                 (BYTE (MINUS 8 *PREV-LENGTH*) 0)
                 (ASH *PREV-BYTE* (MINUS 8 *PREV-LENGTH*)))
--> KERNEL:%DEPOSIT-FIELD LET ASH LDB 
==>
  (KERNEL:%LDB C::SIZE 0 -1)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

  (LOOP FOR ENTRY ACROSS Q-TABS ...)
--> LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF LET* 
==>
  (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
Note: Unable to optimize due to type uncertainty:
      The first argument is a VECTOR, not a SIMPLE-ARRAY.

--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF LET* 
==>
  (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
Note: Unable to optimize due to type uncertainty:
      The first argument is a VECTOR, not a SIMPLE-ARRAY.

  (ENCODE-BLOCK (ZIGZAG (SVREF SAMPLED-BUF POS)) HUFFTABS (SVREF PREDS CN)
   OUT-STREAM)
--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LOOP BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN WRITE-BITS BLOCK LOOP 
--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF 
--> PROGN LET* WRITE-STUFFED DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET 
--> ASH LDB 
==>
  (KERNEL:%LDB C::SIZE 0 -1)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET ASH LDB 
==>
  (KERNEL:%LDB C::SIZE 0 -1)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).
[Last message occurs 2 times]

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF IF 
--> PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET ASH LDB 
==>
  (KERNEL:%LDB C::SIZE 0 -1)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

--> BLOCK LET* COND IF COND IF PROGN WRITE-BITS BLOCK LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF PROGN 
--> LET* WRITE-STUFFED DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET ASH LDB 
==>
  (KERNEL:%LDB C::SIZE 0 -1)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

--> BLOCK LET* COND IF PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK 
--> ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF PROGN LET* 
--> WRITE-STUFFED DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET ASH LDB 
==>
  (KERNEL:%LDB C::SIZE 0 -1)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

--> BLOCK LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET ASH LDB 
==>
  (KERNEL:%LDB C::SIZE 0 -1)
Note: Unable to convert to inline logical ops due to type uncertainty:
      The result is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).

  (LOOP FOR ENTRY IN SAMPLING ...)
--> LET ANSI-LOOP::WITH-MINIMAX-VALUE LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY ANSI-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN COND IF 
--> OR LET IF OR > IF 
==>
  (> #:G186 #:G185)
Note: Forced to do GENERIC-> (cost 10).
      Unable to do inline float comparison (cost 3) because:
      The first argument is a REAL, not a DOUBLE-FLOAT.
      The second argument is a REAL, not a DOUBLE-FLOAT.
      Unable to do inline float comparison (cost 3) because:
      The first argument is a REAL, not a SINGLE-FLOAT.
      The second argument is a REAL, not a SINGLE-FLOAT.
      etc.

==>
  (> #:G181 #:G180)
Note: Forced to do GENERIC-> (cost 10).
      Unable to do inline float comparison (cost 3) because:
      The first argument is a REAL, not a DOUBLE-FLOAT.
      The second argument is a REAL, not a DOUBLE-FLOAT.
      Unable to do inline float comparison (cost 3) because:
      The first argument is a REAL, not a SINGLE-FLOAT.
      The second argument is a REAL, not a SINGLE-FLOAT.
      etc.

  (ASH HT 3)
Note: Forced to do full call.
      Unable to do inline ASH (cost 2) because:
      The result is a (INTEGER -4294967296 4294967288), not a FIXNUM.
      Unable to do inline ASH (cost 3) because:
      The result is a (INTEGER -4294967296 4294967288), not a FIXNUM.
      etc.

  (ASH WD 3)
Note: Forced to do full call.
      Unable to do inline ASH (cost 2) because:
      The result is a (INTEGER -4294967296 4294967288), not a FIXNUM.
      Unable to do inline ASH (cost 3) because:
      The result is a (INTEGER -4294967296 4294967288), not a FIXNUM.
      etc.

  (> (COUNT-RELATION SAMPLING) 10)
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.

  (LOOP FOR ENTRY ACROSS Q-TABS ...)
--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF LET* 
==>
  (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
Note: Forced to do full call.
      Unable to do inline array access (cost 5) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY
                                             (COMPLEX SINGLE-FLOAT) (*)).
      The result is a T, not a (COMPLEX SINGLE-FLOAT).
      Unable to do inline array access (cost 5) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
      The result is a T, not a SINGLE-FLOAT.
      etc.

--> LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF LET* 
==>
  (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
Note: Forced to do full call.
      Unable to do inline array access (cost 5) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY
                                             (COMPLEX SINGLE-FLOAT) (*)).
      The result is a T, not a (COMPLEX SINGLE-FLOAT).
      Unable to do inline array access (cost 5) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
      The result is a T, not a SINGLE-FLOAT.
      etc.

  (LOOP FOR CJ FROM 0 ...)
--> LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY WHEN COND IF >= IF 
==>
  (< CJ #:G23)
Note: Forced to do GENERIC-< (cost 10).
      Unable to do inline fixnum comparison (cost 4) because:
      The first argument is a (INTEGER * 536870911), not a FIXNUM.

--> LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ 1+ 
==>
  (+ CJ 1)
Note: Forced to do GENERIC-+ (cost 10).
      Unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a (INTEGER * 536870910), not a FIXNUM.
      The result is a (INTEGER * 536870911), not a FIXNUM.
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a (INTEGER * 536870910), not a FIXNUM.
      The result is a (INTEGER * 536870911), not a FIXNUM.
      etc.

  (COLORSPACE-CONVERT IMAGE YUV DX DY ...)
--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ * * 
==>
  (* W YD)
Note: Forced to do GENERIC-* (cost 30).
      Unable to do inline fixnum arithmetic (cost 4) because:
      The result is a (INTEGER -288230375614840832 288230376151711744), not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The result is a (INTEGER -288230375614840832 288230376151711744), not a (SIGNED-BYTE
                                                                               32).
      etc.

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ * 
==>
  (* (* W YD) 3)
Note: Forced to do GENERIC-* (cost 30).
      Unable to do inline fixnum arithmetic (cost 3) because:
      The first argument is a (INTEGER -288230375614840832 288230376151711744), not a FIXNUM.
      Unable to do inline fixnum arithmetic (cost 4) because:
      The first argument is a (INTEGER -288230375614840832 288230376151711744), not a FIXNUM.
      etc.

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET 
--> LET LET LET LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN 
--> SETF LET* MULTIPLE-VALUE-BIND LET MINUS THE - THE ASH + + 
==>
  (+ (SVREF *CTAB* (PLUS R R-Y-OFF)) (SVREF *CTAB* (PLUS G G-Y-OFF)))
Note: Forced to do GENERIC-+ (cost 10).
      Unable to do inline float arithmetic (cost 2) because:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
      The result is a NUMBER, not a DOUBLE-FLOAT.
      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 NUMBER, not a SINGLE-FLOAT.
      etc.

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET 
--> LET LET LET LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN 
--> SETF LET* MULTIPLE-VALUE-BIND LET MINUS THE - THE ASH + 
==>
  (+ (+ (SVREF *CTAB* #) (SVREF *CTAB* #)) (SVREF *CTAB* (PLUS B B-Y-OFF)))
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 INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The second argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET 
--> LET LET LET LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN 
--> SETF LET* MULTIPLE-VALUE-BIND LET MINUS THE - THE 
==>
  (ASH (+ (SVREF *CTAB* #) (SVREF *CTAB* #) (SVREF *CTAB* #)) (- SHIFT))
Note: Forced to do full call.
      Unable to do inline ASH (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET 
--> LET LET LET LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN 
--> SETF LET* MULTIPLE-VALUE-BIND LET MINUS THE - THE ASH + + 
==>
  (+ (SVREF *CTAB* (PLUS R R-U-OFF)) (SVREF *CTAB* (PLUS G G-U-OFF)))
Note: Forced to do GENERIC-+ (cost 10).
      Unable to do inline float arithmetic (cost 2) because:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
      The result is a NUMBER, not a DOUBLE-FLOAT.
      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 NUMBER, not a SINGLE-FLOAT.
      etc.

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET 
--> LET LET LET LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN 
--> SETF LET* MULTIPLE-VALUE-BIND LET MINUS THE - THE ASH + 
==>
  (+ (+ (SVREF *CTAB* #) (SVREF *CTAB* #)) (SVREF *CTAB* (PLUS B B-U-OFF)))
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 INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The second argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET 
--> LET LET LET LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN 
--> SETF LET* MULTIPLE-VALUE-BIND LET MINUS THE - THE 
==>
  (ASH (+ (SVREF *CTAB* #) (SVREF *CTAB* #) (SVREF *CTAB* #)) (- SHIFT))
Note: Forced to do full call.
      Unable to do inline ASH (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET 
--> LET LET LET LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN 
--> SETF LET* MULTIPLE-VALUE-BIND LET MINUS THE - THE ASH + + 
==>
  (+ (SVREF *CTAB* (PLUS R R-V-OFF)) (SVREF *CTAB* (PLUS G G-V-OFF)))
Note: Forced to do GENERIC-+ (cost 10).
      Unable to do inline float arithmetic (cost 2) because:
      The first argument is a NUMBER, not a DOUBLE-FLOAT.
      The second argument is a NUMBER, not a DOUBLE-FLOAT.
      The result is a NUMBER, not a DOUBLE-FLOAT.
      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 NUMBER, not a SINGLE-FLOAT.
      etc.

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET 
--> LET LET LET LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN 
--> SETF LET* MULTIPLE-VALUE-BIND LET MINUS THE - THE ASH + 
==>
  (+ (+ (SVREF *CTAB* #) (SVREF *CTAB* #)) (SVREF *CTAB* (PLUS B B-V-OFF)))
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 INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The second argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET 
--> LET LET LET LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN 
--> SETF LET* MULTIPLE-VALUE-BIND LET MINUS THE - THE 
==>
  (ASH (+ (SVREF *CTAB* #) (SVREF *CTAB* #) (SVREF *CTAB* #)) (- SHIFT))
Note: Forced to do full call.
      Unable to do inline ASH (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

  (CRUNCH SAMPLED-BUF POS Q-TAB)
--> BLOCK QUANTIZE BLOCK QUANTIZE-BLOCK LOOP LET LET BLOCK 
--> ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET LET LET BLOCK 
--> ANSI-LOOP::LOOP-BODY TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ SETQ 
==>
  (ASH (SVREF BLOCK-ROW X) -3)
Note: Forced to do full call.
      Unable to do inline ASH (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

  (ENCODE-BLOCK (ZIGZAG (SVREF SAMPLED-BUF POS)) HUFFTABS (SVREF PREDS CN)
   OUT-STREAM)
--> BLOCK LET* COND IF PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK 
--> ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF COND IF PROGN 
--> SETF SETQ DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD 
==>
  (ASH *PREV-BYTE* N)
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 INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LET* COND IF PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK 
--> ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF COND IF PROGN 
--> INCF LET* 
==>
  (+ *PREV-LENGTH* N)
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 result is a NUMBER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a NUMBER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* COND IF PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK 
--> ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF PROGN LET* 
==>
  (ASH *PREV-BYTE* (MINUS 8 *PREV-LENGTH*))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a FIXNUM.
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      etc.

--> BLOCK LET* COND IF PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK 
--> ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF PROGN LET* 
--> WRITE-STUFFED DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::NEW C::MASK)
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a UNSIGNED-BYTE, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* COND IF PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK 
--> ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF PROGN LET* 
--> WRITE-STUFFED DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET LOGIOR LOGAND 
==>
  (LOGNOT C::MASK)
Note: Forced to do full call.
      Unable to do inline (signed-byte 32) arithmetic (cost 1) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a (INTEGER * -1), not a FIXNUM.

--> BLOCK LET* COND IF PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK 
--> ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF PROGN LET* 
--> WRITE-STUFFED DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::INT (LOGNOT C::MASK))
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a (INTEGER * -1), not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LET* COND IF PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK 
--> ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF PROGN LET* 
--> WRITE-STUFFED DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET 
==>
  (LOGIOR (LOGAND C::NEW C::MASK) (LOGAND C::INT (LOGNOT C::MASK)))
Note: Forced to do static-function Two-arg-ior (cost 53).
      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.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The second argument is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* COND IF COND IF PROGN WRITE-BITS BLOCK LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF COND IF 
--> PROGN SETF SETQ DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD 
==>
  (ASH *PREV-BYTE* N)
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 INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LET* COND IF COND IF PROGN WRITE-BITS BLOCK LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF COND IF 
--> PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
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 result is a NUMBER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a NUMBER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* COND IF COND IF PROGN WRITE-BITS BLOCK LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF PROGN 
--> LET* 
==>
  (ASH *PREV-BYTE* (MINUS 8 *PREV-LENGTH*))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a FIXNUM.
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      etc.

--> BLOCK LET* COND IF COND IF PROGN WRITE-BITS BLOCK LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF PROGN 
--> LET* WRITE-STUFFED DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::NEW C::MASK)
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a UNSIGNED-BYTE, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* COND IF COND IF PROGN WRITE-BITS BLOCK LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF PROGN 
--> LET* WRITE-STUFFED DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET LOGIOR 
--> LOGAND 
==>
  (LOGNOT C::MASK)
Note: Forced to do full call.
      Unable to do inline (signed-byte 32) arithmetic (cost 1) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a (INTEGER * -1), not a FIXNUM.

--> BLOCK LET* COND IF COND IF PROGN WRITE-BITS BLOCK LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF PROGN 
--> LET* WRITE-STUFFED DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::INT (LOGNOT C::MASK))
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a (INTEGER * -1), not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LET* COND IF COND IF PROGN WRITE-BITS BLOCK LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF PROGN 
--> LET* WRITE-STUFFED DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET 
==>
  (LOGIOR (LOGAND C::NEW C::MASK) (LOGAND C::INT (LOGNOT C::MASK)))
Note: Forced to do static-function Two-arg-ior (cost 53).
      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.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The second argument is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF IF 
--> PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF COND IF PROGN SETF SETQ 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD 
==>
  (ASH *PREV-BYTE* N)
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 INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF IF 
--> PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
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 result is a NUMBER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a NUMBER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF IF 
--> PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* 
==>
  (ASH *PREV-BYTE* (MINUS 8 *PREV-LENGTH*))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a FIXNUM.
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF IF 
--> PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::NEW C::MASK)
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a UNSIGNED-BYTE, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF IF 
--> PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET LOGIOR LOGAND 
==>
  (LOGNOT C::MASK)
Note: Forced to do full call.
      Unable to do inline (signed-byte 32) arithmetic (cost 1) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a (INTEGER * -1), not a FIXNUM.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF IF 
--> PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::INT (LOGNOT C::MASK))
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a (INTEGER * -1), not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF IF 
--> PROGN WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET 
==>
  (LOGIOR (LOGAND C::NEW C::MASK) (LOGAND C::INT (LOGNOT C::MASK)))
Note: Forced to do static-function Two-arg-ior (cost 53).
      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.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The second argument is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LOOP BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN WRITE-BITS BLOCK LOOP 
--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF 
--> COND IF PROGN SETF SETQ DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD 
==>
  (ASH *PREV-BYTE* N)
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 INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LOOP BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN WRITE-BITS BLOCK LOOP 
--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF 
--> COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
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 result is a NUMBER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a NUMBER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LOOP BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN WRITE-BITS BLOCK LOOP 
--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF 
--> PROGN LET* 
==>
  (ASH *PREV-BYTE* (MINUS 8 *PREV-LENGTH*))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a FIXNUM.
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LOOP BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN WRITE-BITS BLOCK LOOP 
--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF 
--> PROGN LET* WRITE-STUFFED DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET 
--> LOGIOR 
==>
  (LOGAND C::NEW C::MASK)
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a UNSIGNED-BYTE, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LOOP BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN WRITE-BITS BLOCK LOOP 
--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF 
--> PROGN LET* WRITE-STUFFED DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET 
--> LOGIOR LOGAND 
==>
  (LOGNOT C::MASK)
Note: Forced to do full call.
      Unable to do inline (signed-byte 32) arithmetic (cost 1) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a (INTEGER * -1), not a FIXNUM.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LOOP BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN WRITE-BITS BLOCK LOOP 
--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF 
--> PROGN LET* WRITE-STUFFED DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET 
--> LOGIOR 
==>
  (LOGAND C::INT (LOGNOT C::MASK))
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a (INTEGER * -1), not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LOOP BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN WRITE-BITS BLOCK LOOP 
--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LET COND LET IF COND IF 
--> PROGN LET* WRITE-STUFFED DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET 
==>
  (LOGIOR (LOGAND C::NEW C::MASK) (LOGAND C::INT (LOGNOT C::MASK)))
Note: Forced to do static-function Two-arg-ior (cost 53).
      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.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The second argument is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF COND IF PROGN SETF SETQ 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD 
==>
  (ASH *PREV-BYTE* N)
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 INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
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 result is a NUMBER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a NUMBER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* 
==>
  (ASH *PREV-BYTE* (MINUS 8 *PREV-LENGTH*))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a FIXNUM.
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::NEW C::MASK)
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a UNSIGNED-BYTE, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET LOGIOR LOGAND 
==>
  (LOGNOT C::MASK)
Note: Forced to do full call.
      Unable to do inline (signed-byte 32) arithmetic (cost 1) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a (INTEGER * -1), not a FIXNUM.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::INT (LOGNOT C::MASK))
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a (INTEGER * -1), not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET 
==>
  (LOGIOR (LOGAND C::NEW C::MASK) (LOGAND C::INT (LOGNOT C::MASK)))
Note: Forced to do static-function Two-arg-ior (cost 53).
      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.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The second argument is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WHEN COND IF MINUSP 
==>
  (< (SVREF BLOCK K) 0)
Note: Forced to do GENERIC-< (cost 10).
      Unable to do inline fixnum comparison (cost 3) because:
      The first argument is a REAL, not a FIXNUM.
      Unable to do inline fixnum comparison (cost 4) because:
      The first argument is a REAL, not a FIXNUM.
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WHEN COND IF PROGN DECF LET* 
==>
  (- (SVREF #:G134 #:G133) 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 NUMBER, not a FIXNUM.
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a NUMBER, not a FIXNUM.
      The result is a NUMBER, not a FIXNUM.
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF COND IF PROGN SETF SETQ 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD 
==>
  (ASH *PREV-BYTE* N)
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 INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
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 result is a NUMBER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a NUMBER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* 
==>
  (ASH *PREV-BYTE* (MINUS 8 *PREV-LENGTH*))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a FIXNUM.
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::NEW C::MASK)
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a UNSIGNED-BYTE, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET LOGIOR LOGAND 
==>
  (LOGNOT C::MASK)
Note: Forced to do full call.
      Unable to do inline (signed-byte 32) arithmetic (cost 1) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a (INTEGER * -1), not a FIXNUM.

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::INT (LOGNOT C::MASK))
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a (INTEGER * -1), not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LET* LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET 
==>
  (LOGIOR (LOGAND C::NEW C::MASK) (LOGAND C::INT (LOGNOT C::MASK)))
Note: Forced to do static-function Two-arg-ior (cost 53).
      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.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The second argument is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF COND IF PROGN SETF SETQ 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD 
==>
  (ASH *PREV-BYTE* N)
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 INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF COND IF PROGN INCF LET* 
==>
  (+ *PREV-LENGTH* N)
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 result is a NUMBER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a NUMBER, not a (SIGNED-BYTE 32).
      The result is a NUMBER, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* 
==>
  (ASH *PREV-BYTE* (MINUS 8 *PREV-LENGTH*))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a FIXNUM.
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      etc.

--> BLOCK LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::NEW C::MASK)
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a UNSIGNED-BYTE, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET LOGIOR LOGAND 
==>
  (LOGNOT C::MASK)
Note: Forced to do full call.
      Unable to do inline (signed-byte 32) arithmetic (cost 1) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a (INTEGER * -1), not a FIXNUM.

--> BLOCK LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::INT (LOGNOT C::MASK))
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a (INTEGER * -1), not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> BLOCK LET* WRITE-BITS BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY LET COND LET IF COND IF PROGN LET* WRITE-STUFFED 
--> DEPOSIT-FIELD KERNEL:%DEPOSIT-FIELD LET 
==>
  (LOGIOR (LOGAND C::NEW C::MASK) (LOGAND C::INT (LOGNOT C::MASK)))
Note: Forced to do static-function Two-arg-ior (cost 53).
      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.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The second argument is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

  (ASH *PREV-BYTE* (MINUS 8 *PREV-LENGTH*))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a FIXNUM.
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

  (DEPOSIT-FIELD 255
                 (BYTE (MINUS 8 *PREV-LENGTH*) 0)
                 (ASH *PREV-BYTE* (MINUS 8 *PREV-LENGTH*)))
--> KERNEL:%DEPOSIT-FIELD LET LOGIOR LOGAND 
==>
  (LOGAND C::Y 255)
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a UNSIGNED-BYTE, not a FIXNUM.
      Unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
      The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).
      etc.

==>
  (LOGNOT C::MASK)
Note: Forced to do full call.
      Unable to do inline (signed-byte 32) arithmetic (cost 1) because:
      The first argument is a UNSIGNED-BYTE, not a (SIGNED-BYTE 32).
      The result is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a UNSIGNED-BYTE, not a FIXNUM.
      The result is a (INTEGER * -1), not a FIXNUM.

--> KERNEL:%DEPOSIT-FIELD LET LOGIOR 
==>
  (LOGAND C::INT (LOGNOT C::MASK))
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      The second argument is a (INTEGER * -1), not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The first argument is a INTEGER, not a (SIGNED-BYTE 32).
      The second argument is a (INTEGER * -1), not a (SIGNED-BYTE 32).
      The result is a INTEGER, not a (SIGNED-BYTE 32).

--> KERNEL:%DEPOSIT-FIELD LET 
==>
  (LOGIOR (LOGAND C::NEW C::MASK) (LOGAND C::INT (LOGNOT C::MASK)))
Note: Forced to do static-function Two-arg-ior (cost 53).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a INTEGER, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 3) because:
      The second argument is a INTEGER, not a (SIGNED-BYTE 32).
      etc.

  (CRUNCH SAMPLED-BUF POS Q-TAB)
--> BLOCK LLM-DCT BLOCK LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> PROGN LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY PROGN SETF 
--> COMMON-LISP::%SVSET COMMON-LISP::%ASET LET* 
==>
  (KERNEL:DATA-VECTOR-SET ARRAY KERNEL:INDEX C::NEW-VALUE)
Note: Doing signed word to integer coercion (cost 20), for:
      The second argument of DATA-VECTOR-SET/SIMPLE-VECTOR-C.
[Last message occurs 2 times]

Converted ENCODE-IMAGE.
Compiling DEFUN ENCODE-IMAGE: 
Byte Compiling Top-Level Form: 
Byte Compiling Top-Level Form: 
Converted MAKE-SCAN.
Compiling DEFSTRUCT SCAN: 
Byte Compiling Top-Level Form: 
Byte Compiling Creation Form for #<KERNEL::CLASS-CELL SCAN>: 
Converted MAKE-HUFFSTRUCT.
Compiling DEFSTRUCT HUFFSTRUCT: 
Byte Compiling Top-Level Form: 
Byte Compiling Creation Form for #<KERNEL::CLASS-CELL HUFFSTRUCT>: 
Converted MAKE-DESCRIPTOR.
Compiling DEFSTRUCT DESCRIPTOR: 
Converted READ-MARKER.
Compiling DEFUN READ-MARKER: 
Converted READ-WORD.
Compiling DEFUN READ-WORD: 
Converted READ-APP.
Compiling DEFUN READ-APP: 
Converted READ-DRI.
Compiling DEFUN READ-DRI: 
Converted IZIGZAG.
Compiling DEFUN IZIGZAG: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN IZIGZAG
  (LOOP FOR POS FIXNUM ACROSS ...)
--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY SETQ 
==>
  (LENGTH #:G5)
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a (SIMPLE-ARRAY * (*)).
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a VECTOR.

--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF LET* 
==>
  (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
Note: Unable to optimize due to type uncertainty:
      The first argument is a VECTOR, not a SIMPLE-ARRAY.
[Last message occurs 2 times]

Note: Forced to do full call.
      Unable to do inline array access (cost 20) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 29).
      Unable to do inline array access (cost 20) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 29).
      etc.
[Last message occurs 2 times]

Converted READ-DQT.
Compiling DEFUN READ-DQT: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN READ-DQT
  (IZIGZAG INTABLE TABLE)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY SETQ 
==>
  (LENGTH #:G8)
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a (SIMPLE-ARRAY * (*)).
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a VECTOR.

--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ 
--> SETQ AREF LET* 
==>
  (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
Note: Unable to optimize due to type uncertainty:
      The first argument is a VECTOR, not a SIMPLE-ARRAY.
[Last message occurs 2 times]

Note: Forced to do full call.
      Unable to do inline array access (cost 20) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 29).
      Unable to do inline array access (cost 20) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 29).
      etc.
[Last message occurs 2 times]

Converted BUILD-DECODER-TABLES.
Compiling DEFUN BUILD-DECODER-TABLES: 
Byte Compiling Top-Level Form: 
Byte Compiling Creation Form for #<KERNEL::CLASS-CELL DESCRIPTOR>: 
Converted READ-DHT.
Compiling DEFUN READ-DHT: 
Converted INTERPRET-MARKERS.
Compiling DEFUN INTERPRET-MARKERS: 
Converted EXTEND.
Compiling DEFUN EXTEND: 
Converted MAKE-NEXTBIT.
Compiling DEFUN MAKE-NEXTBIT: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN MAKE-NEXTBIT
  (DECF CNT)
--> LET* 
==>
  (SETQ CNT #:G11)
Note: Doing signed word to integer coercion (cost 20), for:
      The second argument of VALUE-CELL-SET.

  (SETF B (ASH B 1))
==>
  (SETQ B (ASH B 1))
Note: Doing signed word to integer coercion (cost 20), for:
      The second argument of VALUE-CELL-SET.

Converted DECODE.
Compiling DEFUN DECODE: 
Converted RECIEVE.
Compiling DEFUN RECIEVE: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN RECIEVE
  (FUNCALL NEXTBIT S)
--> C::%FUNCALL IF 
==>
  (KERNEL:%COERCE-TO-FUNCTION FUNCTION)
Note: Unable to optimize because:
      Might be a symbol, so must call FDEFINITION at runtime.

Converted DECODE-AC.
Compiling DEFUN DECODE-AC: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN DECODE-AC
  (RECIEVE SSSS NEXTBIT S)
--> BLOCK LET LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY SETF SETQ 
--> PLUS THE + THE FUNCALL C::%FUNCALL IF 
==>
  (KERNEL:%COERCE-TO-FUNCTION FUNCTION)
Note: Unable to optimize because:
      Might be a symbol, so must call FDEFINITION at runtime.

  (EXTEND (RECIEVE SSSS NEXTBIT S) SSSS)
--> BLOCK LET IF PLUS THE 
==>
  (+ (THE FIXNUM V) (THE FIXNUM (1+ #)))
Note: Doing signed word to integer coercion (cost 20), for:
      The first result of inline (signed-byte 32) arithmetic.

Converted DECODE-DC.
Compiling DEFUN DECODE-DC: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN DECODE-DC
  (RECIEVE TT NEXTBIT S)
--> BLOCK LET LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY SETF SETQ 
--> PLUS THE + THE FUNCALL C::%FUNCALL IF 
==>
  (KERNEL:%COERCE-TO-FUNCTION FUNCTION)
Note: Unable to optimize because:
      Might be a symbol, so must call FDEFINITION at runtime.

  (EXTEND (RECIEVE TT NEXTBIT S) TT)
--> BLOCK LET 
==>
  (ASH 2 (MINUS TT 2))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The second argument is a (INTEGER -536870906 536870909), not a (UNSIGNED-BYTE
                                                                      29).
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The second argument is a (INTEGER -536870906 536870909), not a (UNSIGNED-BYTE
                                                                      29).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LET IF 
==>
  (< V VT)
Note: Forced to do GENERIC-< (cost 10).
      Unable to do inline fixnum comparison (cost 4) because:
      The second argument is a INTEGER, not a FIXNUM.

--> BLOCK LET IF PLUS THE + THE 1+ + 
==>
  (ASH -1 TT)
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The second argument is a (INTEGER -536870903 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LET IF PLUS THE + THE 1+ 
==>
  (+ (ASH -1 TT) 1)
Note: Forced to do GENERIC-+ (cost 10).
      Unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a INTEGER, not a FIXNUM.
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      etc.

--> BLOCK LET IF PLUS THE 
==>
  (+ (THE FIXNUM V) (THE FIXNUM (1+ #)))
Note: Doing signed word to integer coercion (cost 20) to "<return value>", for:
      The first result of inline (signed-byte 32) arithmetic.

Converted DECODE-BLOCK.
Compiling DEFUN DECODE-BLOCK: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN DECODE-BLOCK
  (DECODE-AC ZZ (HUFFSTRUCT-MAXCODE TAC) (HUFFSTRUCT-MINCODE TAC)
   (HUFFSTRUCT-VALPTR TAC) ...)
--> BLOCK LOOP LET LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY COND 
--> IF COND IF PROGN SETF COMMON-LISP::%SVSET COMMON-LISP::%ASET EXTEND 
--> RECIEVE BLOCK LET LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY SETF 
--> SETQ PLUS THE + THE FUNCALL C::%FUNCALL IF 
==>
  (KERNEL:%COERCE-TO-FUNCTION FUNCTION)
Note: Unable to optimize because:
      Might be a symbol, so must call FDEFINITION at runtime.

  (DECODE-DC (HUFFSTRUCT-MAXCODE TDC) (HUFFSTRUCT-MINCODE TDC)
   (HUFFSTRUCT-VALPTR TDC) (HUFFSTRUCT-HUFFVAL TDC) ...)
--> BLOCK LET EXTEND RECIEVE BLOCK LET LOOP LET BLOCK 
--> ANSI-LOOP::LOOP-BODY TAGBODY SETF SETQ PLUS THE + THE FUNCALL 
--> C::%FUNCALL IF 
==>
  (KERNEL:%COERCE-TO-FUNCTION FUNCTION)
Note: Unable to optimize because:
      Might be a symbol, so must call FDEFINITION at runtime.

--> BLOCK LET EXTEND BLOCK LET 
==>
  (ASH 2 (MINUS TT 2))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The second argument is a (INTEGER -536870904 536870909), not a (UNSIGNED-BYTE
                                                                      29).
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The second argument is a (INTEGER -536870904 536870909), not a (UNSIGNED-BYTE
                                                                      29).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LET EXTEND BLOCK LET IF 
==>
  (< V VT)
Note: Forced to do GENERIC-< (cost 10).
      Unable to do inline fixnum comparison (cost 4) because:
      The second argument is a INTEGER, not a FIXNUM.

--> BLOCK LET EXTEND BLOCK LET IF PLUS THE + THE 1+ + 
==>
  (ASH -1 TT)
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The second argument is a (INTEGER -536870901 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The second argument is a (INTEGER -536870901 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LET EXTEND BLOCK LET IF PLUS THE + THE 1+ 
==>
  (+ (ASH -1 TT) 1)
Note: Forced to do GENERIC-+ (cost 10).
      Unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a INTEGER, not a FIXNUM.
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      etc.

  (DECODE-AC ZZ (HUFFSTRUCT-MAXCODE TAC) (HUFFSTRUCT-MINCODE TAC)
   (HUFFSTRUCT-VALPTR TAC) ...)
--> BLOCK LOOP LET LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY COND 
--> IF COND IF PROGN SETF COMMON-LISP::%SVSET COMMON-LISP::%ASET EXTEND 
--> BLOCK LET IF PLUS THE 
==>
  (+ (THE FIXNUM V) (THE FIXNUM (1+ #)))
Note: Doing signed word to integer coercion (cost 20), for:
      The first result of inline (signed-byte 32) arithmetic.

  (DECODE-DC (HUFFSTRUCT-MAXCODE TDC) (HUFFSTRUCT-MINCODE TDC)
   (HUFFSTRUCT-VALPTR TDC) (HUFFSTRUCT-HUFFVAL TDC) ...)
--> BLOCK LET EXTEND BLOCK LET IF PLUS THE 
==>
  (+ (THE FIXNUM V) (THE FIXNUM (1+ #)))
Note: Doing signed word to integer coercion (cost 20), for:
      The first result of inline (signed-byte 32) arithmetic.

Converted DEQUANTIZE.
Compiling DEFUN DEQUANTIZE: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN DEQUANTIZE
  (MUL (DBREF BLOCK X Y) (DBREF TABLE X Y))
--> THE 
==>
  (* (THE FIXNUM (DBREF BLOCK X Y)) (THE FIXNUM (DBREF TABLE X Y)))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

Converted DCT-LIMIT.
Compiling DEFMACRO DCT-LIMIT: 
Byte Compiling Top-Level Form: 
Converted INVERSE-LLM-DCT.
Compiling DEFUN INVERSE-LLM-DCT: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN INVERSE-LLM-DCT
  (DEQUANTIZE DPTR 2 BLOCK Q-TABLE)
--> BLOCK MUL THE 
==>
  (* (THE FIXNUM (DBREF BLOCK X Y)) (THE FIXNUM (DBREF TABLE X Y)))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (DEQUANTIZE DPTR 6 BLOCK Q-TABLE)
--> BLOCK MUL THE 
==>
  (* (THE FIXNUM (DBREF BLOCK X Y)) (THE FIXNUM (DBREF TABLE X Y)))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL (PLUS Z2 Z3) FIX-0-541196100)
--> THE 
==>
  (* (THE FIXNUM (PLUS Z2 Z3)) (THE FIXNUM FIX-0-541196100))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL Z2 FIX-0-765366865)
--> THE 
==>
  (* (THE FIXNUM Z2) (THE FIXNUM FIX-0-765366865))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (DEQUANTIZE DPTR 0 BLOCK Q-TABLE)
--> BLOCK MUL THE 
==>
  (* (THE FIXNUM (DBREF BLOCK X Y)) (THE FIXNUM (DBREF TABLE X Y)))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (DEQUANTIZE DPTR 4 BLOCK Q-TABLE)
--> BLOCK MUL THE 
==>
  (* (THE FIXNUM (DBREF BLOCK X Y)) (THE FIXNUM (DBREF TABLE X Y)))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (DEQUANTIZE DPTR 7 BLOCK Q-TABLE)
--> BLOCK MUL THE 
==>
  (* (THE FIXNUM (DBREF BLOCK X Y)) (THE FIXNUM (DBREF TABLE X Y)))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (DEQUANTIZE DPTR 5 BLOCK Q-TABLE)
--> BLOCK MUL THE 
==>
  (* (THE FIXNUM (DBREF BLOCK X Y)) (THE FIXNUM (DBREF TABLE X Y)))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (DEQUANTIZE DPTR 3 BLOCK Q-TABLE)
--> BLOCK MUL THE 
==>
  (* (THE FIXNUM (DBREF BLOCK X Y)) (THE FIXNUM (DBREF TABLE X Y)))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (DEQUANTIZE DPTR 1 BLOCK Q-TABLE)
--> BLOCK MUL THE 
==>
  (* (THE FIXNUM (DBREF BLOCK X Y)) (THE FIXNUM (DBREF TABLE X Y)))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL (PLUS Z3 Z4) FIX-1-175875602)
--> THE 
==>
  (* (THE FIXNUM (PLUS Z3 Z4)) (THE FIXNUM FIX-1-175875602))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL TMP0 FIX-0-298631336)
--> THE 
==>
  (* (THE FIXNUM TMP0) (THE FIXNUM FIX-0-298631336))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL TMP1 FIX-2-053119869)
--> THE 
==>
  (* (THE FIXNUM TMP1) (THE FIXNUM FIX-2-053119869))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL TMP2 FIX-3-072711026)
--> THE 
==>
  (* (THE FIXNUM TMP2) (THE FIXNUM FIX-3-072711026))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL TMP3 FIX-1-501321110)
--> THE 
==>
  (* (THE FIXNUM TMP3) (THE FIXNUM FIX-1-501321110))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (LOOP FOR ROW ACROSS BLOCK ...)
--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY SETQ 
==>
  (LENGTH #:G57)
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a (SIMPLE-ARRAY * (*)).
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a VECTOR.

  (MUL (PLUS Z2 Z3) FIX-0-541196100)
--> THE 
==>
  (* (THE FIXNUM (PLUS Z2 Z3)) (THE FIXNUM FIX-0-541196100))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL Z2 FIX-0-765366865)
--> THE 
==>
  (* (THE FIXNUM Z2) (THE FIXNUM FIX-0-765366865))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL (PLUS Z3 Z4) FIX-1-175875602)
--> THE 
==>
  (* (THE FIXNUM (PLUS Z3 Z4)) (THE FIXNUM FIX-1-175875602))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL TMP0 FIX-0-298631336)
--> THE 
==>
  (* (THE FIXNUM TMP0) (THE FIXNUM FIX-0-298631336))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL TMP1 FIX-2-053119869)
--> THE 
==>
  (* (THE FIXNUM TMP1) (THE FIXNUM FIX-2-053119869))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL TMP2 FIX-3-072711026)
--> THE 
==>
  (* (THE FIXNUM TMP2) (THE FIXNUM FIX-3-072711026))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL TMP3 FIX-1-501321110)
--> THE 
==>
  (* (THE FIXNUM TMP3) (THE FIXNUM FIX-1-501321110))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (DEQUANTIZE DPTR 0 BLOCK Q-TABLE)
--> BLOCK MUL THE 
==>
  (* (THE FIXNUM (DBREF BLOCK X Y)) (THE FIXNUM (DBREF TABLE X Y)))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (LOOP FOR ROW ACROSS BLOCK ...)
--> LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF LET* 
==>
  (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
Note: Unable to optimize due to type uncertainty:
      The first argument is a VECTOR, not a SIMPLE-ARRAY.
Note: Forced to do full call.
      Unable to do inline array access (cost 5) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY
                                             (COMPLEX SINGLE-FLOAT) (*)).
      The result is a T, not a (COMPLEX SINGLE-FLOAT).
      Unable to do inline array access (cost 5) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
      The result is a T, not a SINGLE-FLOAT.
      etc.

Converted UPSAMPLE.
Compiling DEFUN UPSAMPLE: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN UPSAMPLE
  (MUL XBASE NCOMP)
--> THE 
==>
  (* (THE FIXNUM XBASE) (THE FIXNUM NCOMP))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL YBASE NWIDTH)
--> THE 
==>
  (* (THE FIXNUM YBASE) (THE FIXNUM NWIDTH))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (LOOP FOR VAL FIXNUM ACROSS ...)
--> LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY SETQ 
==>
  (LENGTH #:G6)
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a (SIMPLE-ARRAY * (*)).
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a VECTOR.

  (MUL (PLUS (1+ Y) DY) NWIDTH)
--> THE 
==>
  (* (THE FIXNUM (PLUS # DY)) (THE FIXNUM NWIDTH))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (LOOP FOR DY FIXNUM FROM ...)
--> LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ 
==>
  (+ DXEND #:G21)
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a FLOAT.

  (LOOP FOR VAL FIXNUM ACROSS ...)
--> LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF LET* 
==>
  (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
Note: Unable to optimize due to type uncertainty:
      The first argument is a VECTOR, not a SIMPLE-ARRAY.
[Last message occurs 2 times]

Note: Forced to do full call.
      Unable to do inline array access (cost 20) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 29).
      Unable to do inline array access (cost 20) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 29).
      etc.

  (LOOP FOR DY FIXNUM FROM ...)
--> LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ 
==>
  (+ DXEND #:G21)
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 result is a REAL, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a REAL, not a (SIGNED-BYTE 32).
      The result is a REAL, not a (SIGNED-BYTE 32).
      etc.

  (LOOP FOR VAL FIXNUM ACROSS ...)
--> LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF LET* 
==>
  (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
Note: Forced to do full call.
      Unable to do inline array access (cost 20) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 29).
      Unable to do inline array access (cost 20) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 29).
      etc.


File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN DECODE-CHUNK
  (INVERSE-LLM-DCT DECODED-BLOCK Q-TAB)
--> BLOCK 
==>
  (LET ((TMP0 0) (TMP1 0) (TMP2 0) (TMP3 0) (TMP10 0) ...)
    (DECLARE (OPTIMIZE # # # #)
             (TYPE FIXNUM TMP0 TMP1 TMP2 ...)
             (TYPE # BLOCK)
             (DYNAMIC-EXTENT TMP0 TMP1 TMP2 TMP3 ...)) ..)
Note: DYNAMIC-EXTENT declaration not implemented.

  (UPSAMPLE IMAGE SCAN DECODED-BLOCK X-POS ...)
--> BLOCK 
==>
  (LET* ((BUFFER #) (NCOMP #) (XBASE #) (YBASE #) (NXBASE #) ...)
    (DECLARE (OPTIMIZE # # # #)
             (TYPE # BLOCK BUFFER)
             (TYPE FIXNUM X Y H ...)
             (DYNAMIC-EXTENT NCOMP XBASE YBASE NXBASE ...)) ..)
Note: DYNAMIC-EXTENT declaration not implemented.

Converted DECODE-CHUNK.
Compiling DEFUN DECODE-CHUNK: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN DECODE-CHUNK
  (POSITION CID (DESCRIPTOR-CID IMAGE))
--> DO BLOCK LET TAGBODY RETURN-FROM 
==>
  (PROGN NIL)
Warning: This is not a FIXNUM:
  NIL
[Last message occurs 2 times]

  (POSITION (FIRST (SVREF # COMP)) (DESCRIPTOR-CID IMAGE))
--> DO BLOCK LET TAGBODY RETURN-FROM 
==>
  (PROGN NIL)
Warning: This is not a FIXNUM:
  NIL

  (UPSAMPLE IMAGE SCAN DECODED-BLOCK X-POS ...)
--> BLOCK LET* MUL THE 
==>
  (* (THE FIXNUM XBASE) (THE FIXNUM NCOMP))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM YBASE) (THE FIXNUM NWIDTH))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

--> BLOCK LET* LOOP LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP 
--> LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY SETQ 
==>
  (LENGTH #:G152)
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a (SIMPLE-ARRAY * (*)).
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a VECTOR.

--> BLOCK LET* LOOP LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP 
--> LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF LOOP LET LET LET 
--> MUL THE 
==>
  (* (THE FIXNUM (PLUS # DY)) (THE FIXNUM NWIDTH))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

--> BLOCK LET* LOOP LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP 
--> LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF LOOP LET LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ 
--> SETQ 
==>
  (+ DXEND #:G167)
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a FLOAT.

  (INVERSE-LLM-DCT DECODED-BLOCK Q-TAB)
--> BLOCK LET LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN SETF 
--> SETQ ASH DEQUANTIZE BLOCK MUL THE 
==>
  (* (THE FIXNUM (DBREF BLOCK X Y)) (THE FIXNUM (DBREF TABLE X Y)))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

--> BLOCK LET LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN SETF 
--> SETQ DEQUANTIZE BLOCK MUL THE 
==>
  (* (THE FIXNUM (DBREF BLOCK X Y)) (THE FIXNUM (DBREF TABLE X Y)))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).
[Last message occurs 2 times]

--> BLOCK LET LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN SETF 
--> SETQ MUL THE 
==>
  (* (THE FIXNUM (PLUS Z2 Z3)) (THE FIXNUM FIX-0-541196100))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

--> BLOCK LET LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN SETF 
--> SETQ PLUS THE + THE MUL THE 
==>
  (* (THE FIXNUM Z2) (THE FIXNUM FIX-0-765366865))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

--> BLOCK LET LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN SETF 
--> SETQ DEQUANTIZE BLOCK MUL THE 
==>
  (* (THE FIXNUM (DBREF BLOCK X Y)) (THE FIXNUM (DBREF TABLE X Y)))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).
[Last message occurs 6 times]

--> BLOCK LET LOOP LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN SETF 
--> SETQ MUL THE 
==>
  (* (THE FIXNUM (PLUS Z3 Z4)) (THE FIXNUM FIX-1-175875602))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP0) (THE FIXNUM FIX-0-298631336))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP1) (THE FIXNUM FIX-2-053119869))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP2) (THE FIXNUM FIX-3-072711026))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP3) (THE FIXNUM FIX-1-501321110))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY SETQ 
==>
  (LENGTH #:G89)
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a (SIMPLE-ARRAY * (*)).
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a VECTOR.

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> SETF SETQ MUL THE 
==>
  (* (THE FIXNUM (PLUS Z2 Z3)) (THE FIXNUM FIX-0-541196100))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> SETF SETQ PLUS THE + THE MUL THE 
==>
  (* (THE FIXNUM Z2) (THE FIXNUM FIX-0-765366865))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF PROGN 
--> SETF SETQ MUL THE 
==>
  (* (THE FIXNUM (PLUS Z3 Z4)) (THE FIXNUM FIX-1-175875602))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP0) (THE FIXNUM FIX-0-298631336))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP1) (THE FIXNUM FIX-2-053119869))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP2) (THE FIXNUM FIX-3-072711026))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

==>
  (* (THE FIXNUM TMP3) (THE FIXNUM FIX-1-501321110))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (IZIGZAG (DECODE-BLOCK (DESCRIPTOR-ZZ IMAGE) (SVREF TABLES COMP) NEXTBIT S)
   *ZZBUF*)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY SETQ 
==>
  (LENGTH #:G20)
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a (SIMPLE-ARRAY * (*)).
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR NULL VECTOR), not a VECTOR.

  (MUL (DESCRIPTOR-WIDTH IMAGE) (DESCRIPTOR-NCOMP IMAGE))
--> THE 
==>
  (* (THE FIXNUM (DESCRIPTOR-WIDTH IMAGE))
     (THE FIXNUM (DESCRIPTOR-NCOMP IMAGE)))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL (DESCRIPTOR-HEIGHT IMAGE) NWIDTH)
--> THE 
==>
  (* (THE FIXNUM (DESCRIPTOR-HEIGHT IMAGE)) (THE FIXNUM NWIDTH))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL NWIDTH V)
--> THE 
==>
  (* (THE FIXNUM NWIDTH) (THE FIXNUM V))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL (DESCRIPTOR-NCOMP IMAGE) H)
--> THE 
==>
  (* (THE FIXNUM (DESCRIPTOR-NCOMP IMAGE)) (THE FIXNUM H))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL (ASH Y 3) V)
--> THE 
==>
  (* (THE FIXNUM (ASH Y 3)) (THE FIXNUM V))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (MUL (ASH X 3) H)
--> THE 
==>
  (* (THE FIXNUM (ASH X 3)) (THE FIXNUM H))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The second argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

  (INCF (DBREF DECODED-BLOCK 0 0) (SVREF PREDS COMP))
--> LET* 
==>
  (+ (THE FIXNUM (SVREF #:G28 #:G27)) (SVREF PREDS COMP))
Note: Unable to optimize due to type uncertainty:
      The second argument is a NUMBER, not a FLOAT.

  (LOOP FOR ENTRY ACROSS FR ...)
--> LET ANSI-LOOP::WITH-MINIMAX-VALUE LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY ANSI-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN COND IF 
--> OR LET IF OR > IF 
==>
  (> #:G204 #:G203)
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a SINGLE-FLOAT.
      The second argument is a REAL, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a DOUBLE-FLOAT.
      The second argument is a REAL, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a FLOAT.
      The second argument is a REAL, not a RATIONAL.
Note: Unable to 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 FLOAT.
      The second argument is a REAL, not a FLOAT.

==>
  (> #:G211 #:G210)
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a SINGLE-FLOAT.
      The second argument is a REAL, not a DOUBLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a DOUBLE-FLOAT.
      The second argument is a REAL, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a REAL, not a FLOAT.
      The second argument is a REAL, not a RATIONAL.
Note: Unable to 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 FLOAT.
      The second argument is a REAL, not a FLOAT.

  (IZIGZAG (DECODE-BLOCK (DESCRIPTOR-ZZ IMAGE) (SVREF TABLES COMP) NEXTBIT S)
   *ZZBUF*)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ 
--> SETQ AREF LET* 
==>
  (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
Note: Unable to optimize due to type uncertainty:
      The first argument is a VECTOR, not a SIMPLE-ARRAY.
[Last message occurs 2 times]

  (INVERSE-LLM-DCT DECODED-BLOCK Q-TAB)
--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF LET* 
==>
  (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
Note: Unable to optimize due to type uncertainty:
      The first argument is a VECTOR, not a SIMPLE-ARRAY.

  (UPSAMPLE IMAGE SCAN DECODED-BLOCK X-POS ...)
--> BLOCK LET* LOOP LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP 
--> LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF LET* 
==>
  (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
Note: Unable to optimize due to type uncertainty:
      The first argument is a VECTOR, not a SIMPLE-ARRAY.
[Last message occurs 2 times]

  (POSITION (FIRST (SVREF # COMP)) (DESCRIPTOR-CID IMAGE))
--> DO BLOCK LET TAGBODY WHEN COND IF FUNCALL 
==>
  (C::%FUNCALL
   (IF (FUNCTIONP FUNCTION) FUNCTION (KERNEL:%COERCE-TO-FUNCTION FUNCTION))
   #:FUNCALL-ARG-441
   #:FUNCALL-ARG-442)
Note: Unable to optimize due to type uncertainty:
      The first argument is a T, not a SINGLE-FLOAT.
      The second argument is a T, not a SINGLE-FLOAT.
Note: Unable to optimize due to type uncertainty:
      The first argument is a T, not a DOUBLE-FLOAT.
      The second argument is a T, not a DOUBLE-FLOAT.

  (LOOP FOR ENTRY ACROSS FR ...)
--> LET ANSI-LOOP::WITH-MINIMAX-VALUE LET BLOCK ANSI-LOOP::LOOP-BODY 
--> TAGBODY ANSI-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN COND IF 
--> OR LET IF OR > IF 
==>
  (> #:G211 #:G210)
Note: Forced to do GENERIC-> (cost 10).
      Unable to do inline float comparison (cost 3) because:
      The first argument is a REAL, not a DOUBLE-FLOAT.
      The second argument is a REAL, not a DOUBLE-FLOAT.
      Unable to do inline float comparison (cost 3) because:
      The first argument is a REAL, not a SINGLE-FLOAT.
      The second argument is a REAL, not a SINGLE-FLOAT.
      etc.

==>
  (> #:G204 #:G203)
Note: Forced to do GENERIC-> (cost 10).
      Unable to do inline float comparison (cost 3) because:
      The first argument is a REAL, not a DOUBLE-FLOAT.
      The second argument is a REAL, not a DOUBLE-FLOAT.
      Unable to do inline float comparison (cost 3) because:
      The first argument is a REAL, not a SINGLE-FLOAT.
      The second argument is a REAL, not a SINGLE-FLOAT.
      etc.

  (LOGAND (SECOND (SVREF # I)) 15)
Note: Forced to do static-function Two-arg-and (cost 53).
      Unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a INTEGER, not a FIXNUM.
      Unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
      The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
      etc.

  (ASH (SECOND (SVREF # I)) -4)
Note: Forced to do full call.
      Unable to do inline ASH (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 3) because:
      The first argument is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

  (POSITION (FIRST (SVREF # COMP)) (DESCRIPTOR-CID IMAGE))
--> DO BLOCK LET TAGBODY WHEN COND IF FUNCALL 
==>
  (C::%FUNCALL
   (IF (FUNCTIONP FUNCTION) FUNCTION (KERNEL:%COERCE-TO-FUNCTION FUNCTION))
   #:FUNCALL-ARG-441
   #:FUNCALL-ARG-442)
Note: Forced to do GENERIC-EQL (cost 10).
      Unable to do inline fixnum comparison (cost 4) because:
      The first argument is a T, not a FIXNUM.
      The second argument is a T, not a FIXNUM.

  (DECODE-BLOCK (DESCRIPTOR-ZZ IMAGE) (SVREF TABLES COMP) NEXTBIT S)
--> BLOCK LET SETF COMMON-LISP::%SVSET COMMON-LISP::%ASET DECODE-DC 
--> BLOCK LET EXTEND BLOCK LET 
==>
  (ASH 2 (MINUS TT 2))
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The second argument is a (INTEGER -536870904 536870909), not a (UNSIGNED-BYTE
                                                                      29).
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The second argument is a (INTEGER -536870904 536870909), not a (UNSIGNED-BYTE
                                                                      29).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LET SETF COMMON-LISP::%SVSET COMMON-LISP::%ASET DECODE-DC 
--> BLOCK LET EXTEND BLOCK LET IF 
==>
  (< V VT)
Note: Forced to do GENERIC-< (cost 10).
      Unable to do inline fixnum comparison (cost 4) because:
      The second argument is a INTEGER, not a FIXNUM.

--> BLOCK LET SETF COMMON-LISP::%SVSET COMMON-LISP::%ASET DECODE-DC 
--> BLOCK LET EXTEND BLOCK LET IF PLUS THE + THE 1+ + 
==>
  (ASH -1 TT)
Note: Forced to do full call.
      Unable to do inline ASH (cost 3) because:
      The second argument is a (INTEGER -536870902 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline ASH (cost 4) because:
      The second argument is a (INTEGER -536870902 536870911), not a (UNSIGNED-BYTE
                                                                      29).
      The result is a INTEGER, not a (INTEGER -2147483648 4294967295).
      etc.

--> BLOCK LET SETF COMMON-LISP::%SVSET COMMON-LISP::%ASET DECODE-DC 
--> BLOCK LET EXTEND BLOCK LET IF PLUS THE + THE 1+ 
==>
  (+ (ASH -1 TT) 1)
Note: Forced to do GENERIC-+ (cost 10).
      Unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a INTEGER, not a FIXNUM.
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      etc.

  (IZIGZAG (DECODE-BLOCK (DESCRIPTOR-ZZ IMAGE) (SVREF TABLES COMP) NEXTBIT S)
   *ZZBUF*)
--> BLOCK LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ 
--> SETQ AREF LET* 
==>
  (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
Note: Forced to do full call.
      Unable to do inline array access (cost 20) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 29).
      Unable to do inline array access (cost 20) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 29).
      etc.
[Last message occurs 2 times]

  (INCF (DBREF DECODED-BLOCK 0 0) (SVREF PREDS COMP))
--> LET* 
==>
  (+ (THE FIXNUM (SVREF #:G28 #:G27)) (SVREF PREDS COMP))
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 (signed-byte 32) arithmetic (cost 5) because:
      The second argument is a NUMBER, not a (SIGNED-BYTE 32).
      etc.

  (INVERSE-LLM-DCT DECODED-BLOCK Q-TAB)
--> BLOCK LET LOOP LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF LET* 
==>
  (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
Note: Forced to do full call.
      Unable to do inline array access (cost 5) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY
                                             (COMPLEX SINGLE-FLOAT) (*)).
      The result is a T, not a (COMPLEX SINGLE-FLOAT).
      Unable to do inline array access (cost 5) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
      The result is a T, not a SINGLE-FLOAT.
      etc.

  (UPSAMPLE IMAGE SCAN DECODED-BLOCK X-POS ...)
--> BLOCK LET* LOOP LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP 
--> LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF LET* 
==>
  (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
Note: Forced to do full call.
      Unable to do inline array access (cost 20) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 29).
      Unable to do inline array access (cost 20) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 29).
      etc.

--> BLOCK LET* LOOP LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP 
--> LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY IF LOOP LET LET LET 
--> BLOCK ANSI-LOOP::LOOP-BODY TAGBODY ANSI-LOOP::LOOP-REALLY-DESETQ 
--> SETQ 
==>
  (+ DXEND #:G167)
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 result is a REAL, not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The first argument is a REAL, not a (SIGNED-BYTE 32).
      The result is a REAL, not a (SIGNED-BYTE 32).
      etc.

--> BLOCK LET* LOOP LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY LOOP 
--> LET LET LET BLOCK ANSI-LOOP::LOOP-BODY TAGBODY 
--> ANSI-LOOP::LOOP-REALLY-DESETQ SETQ AREF LET* 
==>
  (KERNEL:DATA-VECTOR-REF ARRAY KERNEL:INDEX)
Note: Forced to do full call.
      Unable to do inline array access (cost 20) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 29).
      Unable to do inline array access (cost 20) because:
      The first argument is a VECTOR, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 29).
      etc.

  (DECODE-BLOCK (DESCRIPTOR-ZZ IMAGE) (SVREF TABLES COMP) NEXTBIT S)
--> BLOCK LET DECODE-AC BLOCK LOOP LET LET LET LET BLOCK 
--> ANSI-LOOP::LOOP-BODY TAGBODY COND IF COND IF PROGN SETF 
--> COMMON-LISP::%SVSET COMMON-LISP::%ASET EXTEND BLOCK LET IF PLUS THE 
==>
  (+ (THE FIXNUM V) (THE FIXNUM (1+ #)))
Note: Doing signed word to integer coercion (cost 20), for:
      The first result of inline (signed-byte 32) arithmetic.

--> BLOCK LET SETF COMMON-LISP::%SVSET COMMON-LISP::%ASET DECODE-DC 
--> BLOCK LET EXTEND BLOCK LET IF PLUS THE 
==>
  (+ (THE FIXNUM V) (THE FIXNUM (1+ #)))
Note: Doing signed word to integer coercion (cost 20), for:
      The first result of inline (signed-byte 32) arithmetic.

Converted DECODE-SCAN.
Compiling DEFUN DECODE-SCAN: 
Converted LIMIT.
Compiling DEFMACRO LIMIT: 
Converted INVERSE-COLORSPACE-CONVERT.
Compiling DEFUN INVERSE-COLORSPACE-CONVERT: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN INVERSE-COLORSPACE-CONVERT
  (MUL (DESCRIPTOR-WIDTH IMAGE) 3)
--> THE 
==>
  (* (THE FIXNUM (DESCRIPTOR-WIDTH IMAGE)) (THE FIXNUM 3))
Note: Unable to recode as shift and add due to type uncertainty:
      The first argument is a FIXNUM, not a (UNSIGNED-BYTE 32).
      The result is a FIXNUM, not a (UNSIGNED-BYTE 32).

Converted DECODE-FRAME.
Compiling DEFUN DECODE-FRAME: 
Converted DECODE-STREAM.
Compiling DEFUN DECODE-STREAM: 
Converted DECODE-IMAGE.
Compiling DEFUN DECODE-IMAGE: 
Converted JPEG-TO-BMP.
Compiling DEFUN JPEG-TO-BMP: 
Converted ENCODING-WRAPPER.
Compiling DEFUN ENCODING-WRAPPER: 
Byte Compiling Top-Level Form: 

File: /home/users/rem/Tmps/TmpJpeg/cl-jpeg/jpeg.lisp

In: DEFUN INTERPRET-MARKERS
  (READ-COM S)
Warning: Undefined function: READ-COM


In: DEFUN MAKE-NEXTBIT
  (READ-BYTE S)
--> BLOCK LET IF LET 
==>
  (EXTENSIONS:STREAM-READ-BYTE STREAM)
Warning: Undefined function: EXTENSIONS:STREAM-READ-BYTE


Warning: These functions are undefined:
  READ-COM EXTENSIONS:STREAM-READ-BYTE


Compilation unit finished.
  6 warnings
  663 notes


jpeg.x86f written.
Compilation finished in 0:00:29.