anchor.diff:  (defun pprint-linear (s list &optional (colon? T) atsign?)
        (declare (ignore atsign?))
     (pprint-logical-block (s list :prefix (if colon? "(" "")
  -			        :suffix (if colon? ")" ""))
  +                                :suffix (if colon? ")" ""))
       (pprint-exit-if-list-exhausted)
       (loop (write+ (pprint-pop) s)
  -	  (pprint-exit-if-list-exhausted)
  -	  (write-char++ #\space s)
  -	  (pprint-newline+ :linear s))))
  +          (pprint-exit-if-list-exhausted)
  +          (write-char++ #\space s)
  +          (pprint-newline+ :linear s))))
   
   (defun pprint-fill (s list &optional (colon? T) atsign?)
       (declare (ignore atsign?))
     (pprint-logical-block (s list :prefix (if colon? "(" "")
  -			        :suffix (if colon? ")" ""))
  +                                :suffix (if colon? ")" ""))
       (pprint-exit-if-list-exhausted)
       (loop (write+ (pprint-pop) s)
  -	  (pprint-exit-if-list-exhausted)
  -	  (write-char++ #\space s)
  -	  (pprint-newline+ :fill s))))
  +          (pprint-exit-if-list-exhausted)
  +          (write-char++ #\space s)
  +          (pprint-newline+ :fill s))))
   
   (defun pprint-tabular (s list &optional (colon? T) atsign? (tabsize nil))
     (declare (ignore atsign?))
     (when (null tabsize) (setq tabsize 16))
     (pprint-logical-block (s list :prefix (if colon? "(" "")
  -			        :suffix (if colon? ")" ""))
  +                                :suffix (if colon? ")" ""))
       (pprint-exit-if-list-exhausted)
       (loop (write+ (pprint-pop) s)
  -	  (pprint-exit-if-list-exhausted)
  -	  (write-char++ #\space s)
  -	  (pprint-tab+ :section-relative 0 tabsize s)
  -	  (pprint-newline+ :fill s))))
  +          (pprint-exit-if-list-exhausted)
  +          (write-char++ #\space s)
  +          (pprint-tab+ :section-relative 0 tabsize s)
  +          (pprint-newline+ :fill s))))
   
   (defun fn-call (xp list)
     (funcall (formatter "~:<~W~^ ~:I~@_~@{~W~^ ~_~}~:>") xp list))
  
positive.code: (defun write+ (object xp)
    (let ((*parents* *parents*))
      (unless (and *circularity-hash-table*
  		(eq (circularity-process xp object nil) :subsequent))
        (when (and *circularity-hash-table* (consp object))
  	;;avoid possible double check in handle-logical-block.
  	(setq object (cons (car object) (cdr object))))
        (let ((printer (if *print-pretty* (get-printer object *print-pprint-dispatch*) nil))
  	    type)
  	(cond (printer (funcall printer xp object))
  	      ((maybe-print-fast xp object))
  	      ((and *print-pretty*
  		    (symbolp (setq type (type-of object)))
  		    (setq printer (get type 'structure-printer))
  		    (not (eq printer :none)))
  	       (funcall printer xp object))
  	      ((and *print-pretty* *print-array* (arrayp object)
  		    (not (stringp object)) (not (bit-vector-p object))
  		    (not (structure-type-p (type-of object))))
  	       (pretty-array xp object))
  	      (T (let ((stuff
  			 (with-output-to-string (s)
  			   (non-pretty-print object s))))
  		   (write-string+ stuff xp 0 (length stuff)))))))))
  
  (defun non-pretty-print (object s)
    (write object
  
negative.code: (defun handle-standard-< (start end)
    (let ((n (num-args-in-directive start end)))
      `(using-format xp ,(subseq *string* (1- start) end)
                     ,@ (copy-tree (make-list n :initial-element (get-arg))))))
  
  (defun num-args-in-directive (start end)
    (let ((n 0) c i j)
  