anchor.diff:        (symbol-macrolet ((cont (lambda () (if (proper-list-p mnode)
                                              next-level
                                              (lambda (_) (declare (ignore _)) mnode)))))
  -        (traverse/route ((bnode base) (mnode modified)) (rroute invalid-p)
  -          (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)
  -                 :no-object)))))))
  +        (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)))
  
positive.code: 
  ;;; 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))))
  
  (defun find-ref-candidates (tree rroute allowed-distance base)
    (some #'(and (<= (levenshtein-distance rroute a0) allowed-distance) a0)
  
negative.code:              (:mark () mark)
               (:subtree () subtree)
               (:home () (route-normalize home))
               (:home-rroute () home)
               (:valid? () valid?)
               (:alive? () (or valid? recalculated?))
               (:check-in () (cond (valid?  (cons mark rroute))
  