anchor.diff:  
   (defmacro define-unsigned-reader (const-name)
     (let ((docstring
  -	 (format nil
  -		 "Read an unsigned ~A-bit integer from a stream."
  -		 (subseq  (format nil "~A" const-name) 1))))
  +         (format nil
  +                 "Read an unsigned ~A-bit integer from a stream."
  +                 (subseq  (format nil "~A" const-name) 1))))
       `(defun ,(intern (format nil "READ-~A" const-name))
  -	 (stream &key (endian :little))
  +         (stream &key (endian :little))
          ,docstring
          (read-uint stream ,const-name :endian endian))))
   
   (defmacro define-unsigned-writer (const-name)
     (let ((docstring
  -	 (format nil
  -		 "Write an unsigned ~A-bit integer to a stream."
  -		 (subseq  (format nil "~A" const-name) 1))))
  +         (format nil
  +                 "Write an unsigned ~A-bit integer to a stream."
  +                 (subseq  (format nil "~A" const-name) 1))))
       `(defun ,(intern (format nil "WRITE-~A" const-name))
  -	 (stream n &key (endian :little))
  +         (stream n &key (endian :little))
          ,docstring
          (write-uint stream n ,const-name :endian endian))))
   
  
positive.code: (defun uint-from-bytes (bin &key (endian :little))
    "Produce an unsigned integer from the binary array input."
    (let ((bin (cond
  	       ((eql endian :little) bin)
  	       ((eql endian :big)    (reverse bin))
  	       (t (error "Invalid endian specification."))))
  	(n 0))
      (dotimes (i (length bin))
        (setf n (+ n (ash (aref bin i) (* i 8)))))
      n))
  
negative.code: 
  (defun read-int (stream size &key (endian :little))
    (int-from-bytes (octets stream size)
                    :endian endian))
  
  (defun write-int (stream n size &key (endian :little))
    (write-sequence (int-to-bytes n size :endian endian)
                    stream))
  
  (defmacro define-signed-reader (const-name)
    (let ((docstring
           (format nil
                   "Read a signed ~A-bit integer from a stream."
                   (subseq  (format nil "~A" const-name) 1))))
      `(defun ,(intern (format nil "READ-~A" const-name))
           (stream &key (endian :little))
         ,docstring
         (read-int stream ,const-name :endian endian))))
  
  (defmacro define-signed-writer (const-name)
    (let ((docstring
           (format nil
                   "Write a signed ~A-bit integer to a stream."
                   (subseq  (format nil "~A" const-name) 1))))
      `(defun ,(intern (format nil "WRITE-~A" const-name))
           (stream n &key (endian :little))
         ,docstring
         (write-int stream n ,const-name :endian endian))))
  
  