anchor.diff:  
   ;;; The structure retuned from RAWDIFF is called ``rawdiff''.
   (defun rawdiff (base modified refmark lostmark citedmark allowed-distance)
  -  (with-route (node r) (rdiff% base modified refmark lostmark citedmark allowed-distance)
  -    (cond ((functionp node) (if (funcall node :alive?)
  -                              (funcall node :check-in)
  -                              'dead))
  -          ((atom node) node)
  -          (t next-level))))
  +  (multiple-value-bind (modtree basebook) (rdiff% base modified refmark lostmark citedmark allowed-distance)
  +    (values
  +      (with-route (node r) modtree
  +        (cond ((functionp node) (if (funcall node :alive?)
  +                                  (funcall node :check-in)
  +                                  'dead))
  +              ((atom node) node)
  +              (t next-level)))
  +      (construct-losttree base basebook))))
   
   (defun find-ref-candidates (tree rroute allowed-distance base)
     (some #'(and (<= (levenshtein-distance rroute a0) allowed-distance) a0)
  
positive.code:              (:mark () mark)
               (:subtree () subtree)
               (:home () (route-normalize home))
               (:valid? () valid?)
               (:alive? () (or valid? recalculated?))
               (:check-in () (cond (valid?  (cons mark rroute))
  
negative.code:       (symbol-macrolet ((cont (lambda () (if (proper-list-p mnode)
                                             next-level
                                             (lambda (_) (declare (ignore _)) mnode)))))
          (values
            (traverse/route ((bnode base) (mnode modified)) (rroute invalid)
              (cond ((and (not (invalid-p mnode)) (not (invalid-p bnode)))
                     (acond ((equal mnode bnode)
                             (booking-as-ref rroute bnode cont rroute))
                            ((find-ref-candidates mnode rroute allowed-distance base)
                             (booking-as-lost rroute bnode)
                             (booking-as-ref it mnode cont rroute))
                            ((and (not (proper-list-p bnode)) (not (proper-list-p mnode)))
                             (booking-as-lost rroute bnode)
                             mnode)
                            ((not (proper-list-p bnode))
                             (booking-as-lost rroute bnode)
                             next-level)
                            ((not (proper-list-p mnode))
                             (booking-as-lost rroute bnode)
                             mnode)
                            (t next-level)))
                    ((invalid-p bnode)
                     (acond ((find-ref-candidates mnode rroute allowed-distance base)
                             (booking-as-ref it mnode cont rroute))
                            ((proper-list-p mnode) next-level)
                            (t (list mnode))))
                    ((invalid-p mnode)
                     (booking-as-lost rroute bnode)
                     invalid)))
            (remove-if-not #'(funcall _ :alive?) basebook))))))
  
  (defun construct-losttree (base basebook)
    (with-route (node rroute) base
      (aif (member rroute basebook :key #'(funcall _ :home-rroute) :test #'equal)
        (funcall (car it) :check-in)
        next-level)))
  
  (defun refnode-p (node refmark)
    (and (proper-list-p node) (eq (car node) refmark)))
  