anchor.diff:                 ;; S-expressions other than ATOMs as leaves.
                  (if (not (atom leaf))
                    (car (push (cdr leaf) result))))
  -             routeref-diff
  +             refdiff
                :pred (lambda (x) (or (atom x) (eq (car x) refmark))))
       result))
   
  -(defun lost-subtree-list (routeref-diff base refmark lostmark)
  -  (let ((routeref-lst (routeref-list routeref-diff refmark))
  +(defun lostnode-list (refdiff base refmark lostmark)
  +  (let ((refnodes (refnode-list refdiff refmark))
           result)
       (with-route (sub route) base
  -      (cond ((find route routeref-lst :test #'equal) (cons refmark route))
  +      (cond ((find route refnodes :test #'equal) (cons refmark route))
               ((find-if #'(start-with (route-normalize route) (route-normalize _))
  -                      routeref-lst)
  +                      refnodes)
                next-level)
               (t (push (cons lostmark route) result))))
         (nreverse result)))
  
positive.code: ;                             (princ x)
  ;                             (print (showdiff *first-impl* *second-impl* x)))))
  ;  (rdiff base modified 'ref 1)
  ;  (lost-subtree-list (rdiff base modified 'ref 1) base 'ref 'lost))
  
  (defun merge-lost (routeref-diff lost-subtrees refmark)
    (labels ((rec (node route)
                 (let ((lostnodes (remove-if-not (p (equal (drop _ 2) route)) lost-subtrees))
                       (nodelength (length node)))
                   (mapcan (lambda (order)
                             (let* ((cur-item (nth order node))
  
negative.code: ;(printing-let* ((base *first-impl*)
  ;                (modified *impl2*)
  ;                (newnode-detected-diff  (rdiff base modified 'ref 1))
  ;                (lost-subtrees (lostnode-list newnode-detected-diff base 'ref 'lost)))
  ;               newnode-detected-diff
  ;               lost-subtrees
  ;               (merge-lost newnode-detected-diff lost-subtrees 'ref))
  