anchor.diff:    (write-children-text self))
   (define-element-writer button           (:bo :ac)          :children)
   (define-element-writer center           (:bo :ac)          :children)
  -(define-element-writer cite             (:bo :ac)          :children)
  +(define-element-writer cite             ()                 :children)
   (define-element-writer code             ()                 (write-parenthesized-children self "`" "`"))
   (define-element-writer del              ()                 :children)
   (define-element-writer dfn              ()                 :children)
  
positive.code: 
  (defun write-indented-children (self)
    (dolist (line (split-string (with-output-to-string (*standard-output*)
                                  (write-children-text self)) #(#\newline)))
      (princ "   ") (princ line) (terpri)))
  
  (defun write-parenthesized-children (self left right)
  
negative.code: ;;;
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
  
  (defgeneric parse-tree-to-sexp (html)
  
    (:documentation "
  Transforms the sequence of HTML tokens, HTML-SEQ structure defined above,
  into a list of tag forms and contents strings.
  ")
    
    (:method ((self t))  self)
  
    (:method ((self html-seq))
      (do ((current self (html-seq-rest current))
           (result '()))
          ((not (typep current 'html-seq))
           (assert (null current))
           (nreverse result))
        (push (parse-tree-to-sexp (html-seq-first current)) result)))
  
    (:method ((self comment))
      (list :comment
            '() (parse-tree-to-sexp (comment-data self))))
  
    (:method ((self foreign))
      (list :foreign
            '() (parse-tree-to-sexp (foreign-data self))))
  
    (:method ((self attribute))
      (list (intern (string-upcase (attribute-name self)) *tag-package*)
            (or (attribute-value self) t)))
  
    (:method ((self open-tag))
      (list :open
            (intern (string-upcase (open-tag-name self)) *tag-package*)      
            (parse-tree-to-sexp (open-tag-attributes self))))
  
    (:method ((self close-tag))
      (list :close
            (intern (string-upcase (close-tag-name self)) *tag-package*)
            (parse-tree-to-sexp (close-tag-attributes self))))
  
    (:method ((self definition))
      (list* :definition
            '()
            (intern (string-upcase (definition-name self)) *tag-package*)      
            (parse-tree-to-sexp (definition-attributes self)))))
  
  
  
  
  (defun clean-attribute (attr)
    "If the attribute name is quoted or double-quoted, then remove those quotes."
    (cond ((not (stringp attr)) attr)
          ((or (and (<= 2 (length attr))
                    (char= (character "'") (char attr 0))
  