anchor.diff:                            :initial-element nil)))
       (loop for (q0 z q1) in (fa-edges fa)
          do (push q0 (aref move q1 z)))
  +    ;;(format t "~&~A" move)
       (lambda (i-state i-token) (aref move i-state i-token))))
  +
  +(defun fa-successor-array (fa)
  +  "Make array indexed by original state of edge lists from that state."
  +  (let ((array (make-array (length (fa-states fa)) :initial-element nil)))
  +    (map nil (lambda (e) (push e (aref array (car e)))) (fa-edges fa))
  +    array))
  +
  +(defun fa-predecessor-array (fa)
  +  "Make array indexed by final state of edge lists to that state."
  +  (let ((array (make-array (length (fa-states fa)) :initial-element nil)))
  +    (map nil (lambda (e) (push e (aref array (caddr e)))) (fa-edges fa))
  +    array))
   
   (defun fa-dot (fa &optional output )
     "Graphviz output of dfa.
  
positive.code:             :edges (mapcar #'reverse (fa-edges fa))
              :start (fa-accept fa)
              :accept (fa-start fa)))
  
  
  ;;; Regex
  
negative.code:                  for u = (sort (nfa-move-e-closure ds i-z mover) #'<)
                   when u
                   do (progn
                        (assert (null (set-difference u (nfa-e-closure u mover))))
                        (when (not (gethash u d-hash))
                          (setf (gethash u d-hash) (length d-states))
                          (vector-push-extend u d-states))
                        (push (list mark (fa-token-name nfa i-z) (gethash u d-hash))
                              d-edge)))))
        ;; result
        ;;(print nfa)
        ;;(print d-states)
        ;;(print (fa-subset-indices (fa-start nfa) d-states))
        ;;(print (fa-subset-indices (fa-accept nfa) d-states))
        (loop for ds across d-states
           do (assert (= 1 (loop for dt across d-states
                              counting (equal ds dt)))))
        (let ((fa (make-fa d-edge
                           0
                           (fa-subset-indices (fa-accept nfa) d-states))))
          (assert (dfap fa))
          fa))))
  
  ;; Brzozowski's Algorithm
  (defun dfa-minimize-brzozowski (dfa)
  