anchor.diff:    "Depth of the tag being output.")
   
   (defvar *pre* nil)
  +
  +(defparameter *fill-column* 80
  +  "Column at which to wrap text.
  +This is always measured from the start of the tag.")
   
   (defun fast-format (stream control-string &rest args)
     "Like `format', but bind `*print-pretty*' to nil."
  
positive.code: 
  (defun format-attributes/inline (attrs &optional (stream *html*))
    (declare (stream stream))
    (if (null attrs)
        (write-char #\> stream)
        (let ((seen '()))
          ;; Ensure that the leftmost keyword has priority,
          ;; as in function lambda lists.
          (labels ((seen? (name)
                     (declare (optimize speed)
                              (symbol name))
                     (prog1 (member name seen)
                       (push name seen)))
                   (format-attr (attr value)
                     (unless (or (null value) (seen? attr))
                       (write-char #\Space stream)
                       (if (boolean? attr)
                           (progn
                             (pprint-newline :fill stream)
                             (format stream "~(~a~)" attr))
                           (let ((value (format-attribute-value value)))
                             (pprint-newline :fill stream)
                             (format stream "~(~a~)=" attr)
                             (pprint-newline :fill stream)
                             (format stream "~a" value)))))
                   (dynamic-attrs (attrs)
                     (loop for (a v . rest) on attrs by #'cddr
                           do (format-attr a (escape-value v))
                              (when rest
                                (write-char #\Space stream)))))
            (declare (inline seen?))
            (loop for attr = (pop attrs)
                  for value = (pop attrs)
                  if (eql attr :attrs)
                    do (dynamic-attrs value)
                  else do (format-attr attr value)
                          (when (null attrs)
                            (loop-finish))
                          (pprint-newline :fill stream))))))
  
  (defun format-attributes (attrs &optional (stream *html*))
    (declare (stream stream))
    (if (null attrs)
        (write-char #\> stream)
        (let ((seen '())
              *print-lines* *print-miser-width*
              *print-level* *print-length*)
          ;; Ensure that the leftmost keyword has priority,
          ;; as in function lambda lists.
          (pprint-logical-block (stream attrs)
  
negative.code:             `(princ ,arg ,stream))
            `(fast-format ,stream (formatter ,control-string) ,@args))
        call))
  
  (defun indent (&optional (stream *html*) (col *depth*))
    (when *print-pretty*
      (format stream "~V,0T" col)))
  
  (defun newline-and-indent (&optional (stream *html*))
    "Fresh line and indent according to *DEPTH*."
    (when *print-pretty*
      (format stream "~&~V,0T" *depth*)))
  
  (defmacro without-trailing-space (&body body)
    `(let ((*pending-space* nil))
  