anchor.diff:    (and (shorter x y)
          (equal x (take y (length x)))))
   
  -(defun reserve-route (rroute subtree ref-mark)
  +(defun start-with-or-equal (x y)
  +  (or (equal x y) (start-with x y)))
  +
  +;; TODO: subtree is not used at all.
  +(defun reserve-route (rroute found-rroute subtree mark)
     (let ((reserved t))
       (dlambda (:route () (route-normalize rroute))
  -             (:resolve () (if reserved (cons ref-mark rroute) subtree))
  +             (:resolve () (if reserved (cons mark rroute) subtree))
  +             (:found-rroute () found-rroute)
                (:cancel () (setf reserved nil)))))
   
   (defun in-reserved-list (rroute reserved-list)
  
positive.code: 
  ;;; RDIFF function returns a diff format called ``refdiff''
  (defun rdiff (base modified refmark allowed-distance)
    (with-route (node r) (rdiff% base modified refmark allowed-distance)
      (cond ((functionp node) (funcall node :resolve))
            ((atom node) node)
            (t next-level))))
  
  (defun rdiff% (base modified refmark allowed-distance)
    (let (reserved-routes)
      (with-route (cur route) modified
        (acond ((multiple-value-bind (code detected)
  
negative.code:        (labels ((,rec (,subtree-var ,route-var)
                    ,@body))
           (,rec ,tree (list 0))))))
  
  (defmacro traverse/route (var-tree-pairs route-var invalid-p-name style &body body)
    (with-gensyms (rec order maxorder invalid-node)
      (let* ((variables (mapcar #'car var-tree-pairs))
             (sub-vars (mapcar #'(gensym (concat-str "SUB-" (string _))) variables)))
        `(let ((,invalid-node (gensym)))
           (labels ((,invalid-p-name (node)
                      (eq node ,invalid-node)))
             (symbol-macrolet ((next-level
                                 (if (,(case style
                                         (:union 'or)
                                         (:intersection 'and)
                                         (t style))
                                       ,@(mapcar #`(proper-list-p ,a0) variables))
                                   (let ((,maxorder (max ,@(mapcar #`(length (check #'listp ,a0)) variables))))
                                     (loop :for ,order = 0 :then (1+ ,order)
                                           ,@(mapcan #2`(:for ,a0 :in (fillin (check #'listp ,a1) ,maxorder ,invalid-node))
                                                     sub-vars variables)
                                           :collect (,rec ,@sub-vars (cons ,order ,route-var)))))))
               (labels ((,rec (,@variables ,route-var)
                          ,@body))
                 (,rec ,@(mapcar #'second var-tree-pairs) (list 0)))))))))
  
  (defun find-route (subtree code)
    (let (result)
  