anchor.diff:             with old-code
              while (not (= code +end-of-information-code+))
              do 
  -           (cond ((= code +clear-code+)
  -                  (initialize-vector-table))
  -                 (t
  -                  (let ((string (vector-from-code code)))
  -                    (write-decoded-vector string)
  -                    (when old-code
  -                      (add-vector-to-table
  -                       (concatenate 'vector
  -                                    (vector-from-code old-code)
  -                                    (vector (elt string 0))))))
  -                  (setf old-code code))))))
  +             (cond ((= code +clear-code+)
  +                    (initialize-vector-table)
  +                    (setf old-code nil))
  +                   (t
  +                    (let ((string (vector-from-code code)))
  +                      (if string
  +                          (progn
  +                            (write-decoded-vector string)
  +                            (when old-code
  +                              (add-vector-to-table
  +                               (concatenate 'vector
  +                                            (vector-from-code old-code)
  +                                            (subseq string 0 1)))))
  +                          (let ((v (concatenate 'vector
  +                                                (vector-from-code old-code)
  +                                                (subseq (vector-from-code old-code)
  +                                                        0 1))))
  +                            (write-decoded-vector v)
  +                            (add-vector-to-table v))))
  +                    (setf old-code code))))))
       (unless stream output)))
   
  
positive.code: ;;     } /* end of not-ClearCode case */ 
  ;;  } /* end of while loop */ 
  
  #+:lzw-debugging
  (defun lzw-decode-codes (compressed-vector)
    (declare (optimize (debug 2)))
    (let ((bit-offset 0)
          (code-size +initial-code-size+))
      (labels ((get-next-code ()
                 (get-bits compressed-vector
                           bit-offset
                           (incf bit-offset code-size))))
        (loop for code = (get-next-code)
           while (not (= code +end-of-information-code+))
           collect code))))
  
  (defun lzw-decode (compressed-vector &key stream)
  
negative.code:                             :adjustable t)))
      (flet ((initialize-vector-table ()
               (setf vector-hash (make-hash-table :test 'equal)
                     next-entry +first-entry+
                     code-size +initial-code-size+))
             (get-next-code ()
               (let ((code (get-bits compressed-vector
                                     input-bit-offset
                                     (incf input-bit-offset code-size))))
                 
                 code))
             (vector-from-code (code)
               (if (< code +clear-code+)
                   (vector code)
                   (gethash code vector-hash)))
             (add-vector-to-table (vector)
               (setf (gethash next-entry vector-hash) vector)
               (incf next-entry)
               (when (= next-entry (- (expt 2 code-size) 1))
                 (incf code-size)))
             (write-code (int)
               (ensure-array-size-and-set-fill-pointer
                output output-byte-offset)
  