anchor.diff:                       (:partly
                          (mapc #'(funcall _ :cancel) booking)
                          (mapc #'(funcall _ :cancel) (collect-partly-bookings
  -                                                     (route-normalize cited) modbook))
  +                                                     (route-normalize cited) modbook :route))
                          (stack-ref-booking cited node cont cur))
                        (:direct (cond ((eq mark lostmark)
                                        (funcall booking :cancel)
  
positive.code:                    (push (route-booking lostmark rroute node) basebook))))
               (stack-ref-booking (cited node cont cur)
                 (push (route-booking citedmark cur node nil cited) basebook)
                 (car (push (route-booking refmark cited node cont) modbook))))
        (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 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)))
  
negative.code:   (or (equal x y) (start-with x y)))
  
  (defun route-booking (mark rroute subtree &optional cont (home rroute))
    (let ((valid? t))
      (dlambda (:route () (route-normalize rroute))
               (:rroute () rroute)
               (:mark () mark)
  