anchor.diff:         (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)
  
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:   (and (shorter x y)
         (equal x (take y (length x)))))
  
  (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 mark rroute) subtree))
               (:found-rroute () found-rroute)
               (:cancel () (setf reserved nil)))))
  
  (defun in-reserved-list (rroute reserved-list)
  