anchor.diff:  
   (defun save-file (file size stream)
     (multiple-value-bind (full-blocks partial)
  -      (truncate size 512)
  +      (truncate size +block-size+)
       (ensure-directories-exist file)
       (with-open-file (outstream file
                        :direction :output
  
positive.code:     (76 :long-name)
      (53 :directory)
      (103 :global-header)
      (t :unsupported)))
  
  (defun full-path (header)
  
negative.code: (in-package #:ql-minitar)
  
  (defconstant +block-size+ 512)
  (defconstant +space-code+ 32)
  (defconstant +newline-code+ 10)
  (defconstant +equals-code+ 61)
  
  (defun make-block-buffer ()
    (make-array +block-size+ :element-type '(unsigned-byte 8) :initial-element 0))
  
  (defun skip-n-blocks (n stream)
    (let ((block (make-block-buffer)))
      (dotimes (i n)
        (read-sequence block stream))))
  
  (defun read-octet-vector (length stream)
    (let ((block (make-block-buffer))
          (vector (make-array length :element-type '(unsigned-byte 8)))
          (offset 0)
          (block-count (ceiling length +block-size+)))
      (dotimes (i block-count)
          (read-sequence block stream)
          (replace vector block :start1 offset)
          (incf offset +block-size+))
      vector))
  
  
  (defun decode-pax-header-record (vector offset)
    "Decode VECTOR as pax extended header data. Returns the keyword and
  value it specifies as multiple values."
    ;; Vector format is: "%d %s=%s\n", <length>, <keyword>, <value>
    ;; See http://pubs.opengroup.org/onlinepubs/009695399/utilities/pax.html
    (let* ((length-start offset)
           (length-end (position +space-code+ vector :start length-start))
           (length-string (ascii-subseq vector length-start length-end))
           (length (parse-integer length-string))
           (keyword-start (1+ length-end))
           (keyword-end (position +equals-code+ vector :start keyword-start))
           (keyword (ascii-subseq vector keyword-start keyword-end))
           (value-start (1+ keyword-end))
           (value-end (1- (+ offset length)))
           (value (ascii-subseq vector value-start value-end)))
      (values keyword value (+ offset length))))
  
  (defun decode-pax-header (vector)
    "Decode VECTOR as a pax header and return it as an alist."
    (let ((header nil)
          (offset 0)
          (length (length vector)))
      (loop
        (when (<= length offset)
          (return header))
        (multiple-value-bind (keyword value new-offset)
            (decode-pax-header-record vector offset)
          (setf header (acons keyword value header))
          (setf offset new-offset)))))
  
  (defun pax-header-path (vector)
    "Decode VECTOR as a pax header and return its 'path' value, if
    any."
    (let ((header-alist (decode-pax-header vector)))
      (cdr (assoc "path" header-alist :test 'equal))))
  
  (defun ascii-subseq (vector start end)
    (let ((string (make-string (- end start))))
  