anchor.diff:              (values it
                       (route-relation route (funcall it :home))
                       (funcall it :mark)))
  -           ((collect-partly-bookings route basebook)
  +           ((collect-partly-bookings route basebook :home)
               (values it :partly t))
              (t (values nil nil nil)))))
   
  -(defun rdiff% (base modified refmark lostmark citedmark allowed-distance)
  +(defun rdiff% (base modified allowed-distance newmark refmark lostmark citedmark)
     (let (basebook modbook)
       (labels ((booking-as-ref (cited node cont cur)
                  (multiple-value-bind (booking relation mark)
  
positive.code:              (:home () (route-normalize home))
               (:home-rroute () home)
               (:valid? () valid?)
               (:alive? () (or valid? recalculated?))
               (:check-in () (cond (valid?  (cons mark rroute))
                                   (recalculated? (funcall (alambda (ch)
                                                             (if (functionp ch)
                                                               (funcall ch :check-in)
                                                               (mapcar #'self ch)))
                                                           subtree))
                                   (t subtree)))
               (:cancel ()
                (setf valid? nil)
                (when cont
                  (setf recalculated? t)
                  (setf subtree (funcall cont)))))))
  
  ;;; The structure retuned from RAWDIFF is called ``rawdiff''.
  (defun rawdiff (base modified refmark lostmark citedmark allowed-distance)
    (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)
  
negative.code:                                              (:direct (push (route-booking citedmark cur subnode nil subrroute) basebook))
                                               (:indirect next-level)
                                               (t (push (route-booking lostmark subrroute subnode) basebook)))))
                                         (push (route-booking refmark cited node cont cur) modbook))
                                        ((eq mark citedmark) (funcall cont)))))
                     (stack-ref-booking cited node cont cur))))
               (booking-as-new (rroute node)
                 (push (route-booking newmark rroute node) modbook))
               (booking-as-lost (rroute node)
                 (multiple-value-bind (booking relation)
                   (check-booking rroute basebook)
  