anchor.diff:  (defun state-information (state)
     (cons (state-name state)
   	(if (final-state-p state)
  -	    (state-tag state)
  +	    (state-action state)
   	    (loop for transition in (state-transitions state)
   		  for label = (transition-label transition)
   		  for target = (transition-target transition)
  
positive.code: ;;; We represent the automaton as nested lists.  We deliberately avoid
  ;;; using classes so as to avoid circular dependencies.
  
  ;;; A STATE of the automaton is either a FINAL STATE or an INTERNAL
  ;;; state.  A final state has no transitions associated with it, and
  ;;; instead it has a TAG which is a non-NIL atom.  Final states with
  ;;; identical (EQ) tags are considered equivalent.  An internal state
  ;;; has a list of transitions associated with it.  During construction
  ;;; of the automaton, some internal states may have an empty list of
  ;;; transitions, but in the final automaton, every internal state has
  ;;; a non-empty list of transitions associated with it.  There can
  ;;; never be two transitions in a state with the same label (see
  ;;; below).  Two internal states with the same set of transitions
  ;;; (same number of transitions, same labels, leading to equivalent
  ;;; states) are considered equivalent.  A state is represented as a
  ;;; CONS cell.  The CAR of the cell is initially NIL and will later be
  ;;; used to hold a GENSYMed NAME of the state.  If the state is a
  ;;; final state, then the CDR of the CONS cell contains the tag.  If
  ;;; the state is an internal state, the CDR of the CONS cell contains
  ;;; the list of transitions.
  
  ;;; FIXME: We are using the following standard Common Lisp functions
  ;;; that are defined to work on sequences, rather than just lists:
  
negative.code:     result))
  
  ;;; Given an automaton, a list of transition labels (of length N) and
  ;;; a action of a final state, add states and transitions to the
  ;;; automaton, so that there exists a path from the initial state to a
  ;;; final state with the given action.
  ;;;
  ;;; The automaton must not already contain a path from the initial
  ;;; state to a final state with the labels given, not even to a final
  ;;; state with the same action as the one given.
  (defun add-path (automaton labels action)
    (let ((state (car (layer-states (car automaton)))))
      (pop automaton)
      ;; Follow transitions in the automaton until we find a state where
  