anchor.diff:                                (position-if (lambda (q) (find (car q-next) q))
                                              p))
                           edges)))
  -      (make-fa edges
  -               (fa-subset-indices (fa-start dfa) p)
  -               (fa-subset-indices (fa-accept dfa) p)))))
  +
  +      (let ((fa (make-fa edges
  +                         (fa-subset-indices (fa-start dfa) p)
  +                         (fa-subset-indices (fa-accept dfa) p))))
  +        (assert (dfap fa))
  +        fa))))
   
   
   ;; (defun nfa-e-close (n e-lookup)
  
positive.code:             :edges (mapcar #'reverse (fa-edges fa))
              :start (fa-accept fa)
              :accept (fa-start fa)))
  
  
  ;;; Regex
  
negative.code:                            (visit (car (funcall mover i-q (aref token-old i-z))))))))
                (visit (car (fa-start fa)))))))
      ;; Build sorted FA
      (fa-renumber fa :state-map state-old :token-map token-old)))
  
  
  (defun dfa-equal (a b)
    "Check equivalence up to state names of DFAs"
    (assert (dfap a))
    (assert (dfap b))
    (equalp (dfa-sort a) (dfa-sort b)))
  
  (defun fa-mover (fa)
  