anchor.diff:  
   (defun lzw-encode (raw-vector)
     (declare (optimize (debug 2)))
  -  (let ((vector-hash)
  -        (next-entry)
  -        (bit-count 0)
  -        (output (make-array 256
  -                            :element-type '(unsigned-byte 8)
  -                            :fill-pointer 0
  -                            :adjustable t)))
  -    (labels ((initialize-vector-table ()
  -               (setf vector-hash (make-hash-table :test 'equalp)
  -                     next-entry +first-entry+))
  -             (lookup-vector (vector)
  -               (cond ((= (length vector) 1)
  -                      (char-code (elt vector 0)))
  -                     ((> (length vector) 1)
  -                      (gethash vector vector-hash))
  -                     (t (error "huh?"))))
  -             (add-vector (vector)
  -               (setf (gethash vector vector-hash) next-entry)
  -               (incf next-entry))
  -             (code-size ()
  -               (integer-length next-entry))
  -             (write-code (int)
  -               (let ((new-fill-pointer
  -                      (1+ (ash (+ bit-count (code-size)) -3))))
  -                 (ensure-array-size-and-set-fill-pointer
  -                  output new-fill-pointer)
  -                 (set-bits output bit-count (+ bit-count (code-size))
  -                           int))
  -               (incf bit-count (code-size))
  -               (when (= int +clear-code+)
  -                 (progn
  -                   ;; FIXME
  -                   ;; do something special here
  -                   ))))
  -      (initialize-vector-table)
  -      (write-code +clear-code+)
  -      (let ((omega))
  -        (loop for k across raw-vector
  -           do
  -             (let ((cat (concatenate 'vector omega (vector k))))
  -               (if (lookup-vector cat)
  -                   (setf omega cat)
  -                   (progn
  -                     (write-code (lookup-vector omega))
  -                     (add-vector cat)
  -                     (setf omega (vector k))
  -                     (when (= next-entry 4093)
  -                       (write-code +clear-code+))))))
  -        (write-code (lookup-vector omega)))
  -      (write-code +end-of-information-code+)
  -      output)))
  +  (typecase raw-vector
  +    (string
  +     (lzw-encode
  +      (map 'vector #'char-code raw-vector)))
  +    (vector
  +     (let ((vector-hash (make-hash-table :test 'equalp))
  +           (next-entry)
  +           (bit-count 0)
  +           (output (make-array 256
  +                               :element-type '(unsigned-byte 8)
  +                               :fill-pointer 0
  +                               :adjustable t)))
  +       (labels ((initialize-vector-table ()
  +                  (clrhash vector-hash)
  +                  (setf next-entry +first-entry+))
  +                (lookup-vector (vector)
  +                  (cond ((= (length vector) 1)
  +                         (elt vector 0))
  +                        ((> (length vector) 1)
  +                         (gethash vector vector-hash))
  +                        (t (error "huh?"))))
  +                (add-vector (vector)
  +                  (setf (gethash vector vector-hash) next-entry)
  +                  (incf next-entry))
  +                (code-size ()
  +                  (integer-length next-entry))
  +                (write-code (int)
  +                  (let ((new-fill-pointer
  +                         (1+ (ash (+ bit-count (code-size)) -3))))
  +                    (ensure-array-size-and-set-fill-pointer
  +                     output new-fill-pointer)
  +                    (set-bits output bit-count (+ bit-count (code-size))
  +                              int))
  +                  (incf bit-count (code-size))
  +                  (when (= int +clear-code+)
  +                    (progn
  +                      ;; FIXME
  +                      ;; do something special here
  +                      ))))
  +         (initialize-vector-table)
  +         (write-code +clear-code+)
  +         (let ((omega))
  +           (loop for k across raw-vector
  +              do
  +              (let ((cat (concatenate 'vector omega (vector k))))
  +                (if (lookup-vector cat)
  +                    (setf omega cat)
  +                    (progn
  +                      (write-code (lookup-vector omega))
  +                      (add-vector cat)
  +                      (setf omega (vector k))
  +                      (when (= next-entry +max-code+)
  +                        (write-code +clear-code+)
  +                        (initialize-vector-table))))))
  +           (write-code (lookup-vector omega)))
  +         (write-code +end-of-information-code+)
  +         output)))))
   
   (defconstant +initial-code-size+ 9)
   
  
positive.code:                             :adjustable t)))
      (flet ((initialize-vector-table ()
               (setf vector-hash (make-hash-table :test 'equal)
                     next-entry +first-entry+))
             (get-next-code ()
               (get-bits compressed-vector
                         input-bit-offset
                         (incf input-bit-offset code-size)))
             (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))
             (write-code (int)
               (ensure-array-size-and-set-fill-pointer
                output output-byte-offset)
  
negative.code:            with old-code
             while (not (= code +end-of-information-code+))
             do 
               (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)))
  
  