anchor.diff:  ;;; achieve a suite a certain consistensy, it is good to introduce a
   ;;; special data structure for new node, too.  Moreover, nodes can
   ;;; be expressed as a class.
  -(defun apply-converters (diff base refmark lostmark newnode-converter lostnode-converter refnode-converter)
  -  (with-route (cur route) diff
  -    (cond ((refnode-p cur refmark)
  -           (funcall refnode-converter cur route
  -                    (retrieve-by-route base (route-normalize (drop cur)))))
  -          ((lostnode-p cur lostmark)
  -           (funcall lostnode-converter cur route
  -                    (retrieve-by-route base (route-normalize (drop cur)))))
  -          ((newnode-p cur refmark lostmark)
  -           (funcall newnode-converter cur route cur))
  -          (t next-level))))
  +(defun apply-converters (base modified reftree losttree
  +                              newmark refmark lostmark citedmark
  +                              newnode-converter refnode-converter
  +                              lostnode-converter citednode-converter)
  +  (values
  +    (with-route (node rroute) reftree
  +      (cond ((refnode-p node refmark)
  +             (funcall refnode-converter node rroute
  +                      (retrieve-by-route base (nroute<-node node))))
  +            ((newnode-p node newmark)
  +             (funcall newnode-converter node rroute
  +                      (retrieve-by-route modified (nroute<-node node))))
  +            (t next-level)))
  +    (with-route (node rroute) losttree
  +      (cond ((lostnode-p node lostmark)
  +             (funcall lostnode-converter node rroute
  +                      (retrieve-by-route base (nroute<-node node))))
  +            ((citednode-p node citedmark)
  +             (funcall citednode-converter node rroute
  +                      (retrieve-by-route base (nroute<-node node))))
  +            (t next-level)))))
  +
  +(defun nroute<-node (node)
  +  (route-normalize (drop node)))
   
   ;;; An easy-converter takes a codelet as its only argument.
   (defun apply-modifiednode-converters
  
positive.code:                                        (t style))
                                       ,@(mapcar #`(proper-list-p ,a0) variables))
                                   (let ((,maxorder (max ,@(mapcar #`(length (check #'listp ,a0)) variables))))
                                     (remove ,invalid-node
                                             (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)))))))))
  
negative.code:   (and (proper-list-p node) (eq (car node) citedmark)))
  
  ;;; The structure returned from DIFF is called ``diff.''
  (defun diff (base modified allowed-distance
                      &optional (newmark (gensym "NEW"))
                      (refmark (gensym "REF"))
                      (lostmark (gensym "LOST"))
                      (citedmark (gensym "CITED")))
    (multiple-value-call #'(values (retrieve-from-rawdiff a0)
                                   (retrieve-from-rawdiff a1)
                                   newmark refmark lostmark citedmark)
      (rawdiff base modified allowed-distance newmark refmark lostmark citedmark)))
  
  (defun retrieve-from-rawdiff (rawdiff)
    (with-route (node rr) rawdiff
      (if (functionp node)
        (funcall node :check-in)
        next-level)))
  
  ;;; A converter is a 3 parameter function. It takes node, route, and
  ;;; codelet. A converter should return a codelet
  