anchor.diff:                   ))))
             (dolist (g (kernel-gotos k))
               (when (not (terminal-p (goto-symbol g) grammar))
  -              (set-goto k (list (goto-symbol g)) (goto-target g))))))
  +              (set-goto k (list (goto-symbol g)) (goto-target g)))))
  +        (dolist (k kernels)
  +          (let* ((i (kernel-id k))
  +                 (alist (mapcar #'cdr (aref action i))))
  +            (when (every #'action-equal-p alist (cdr alist))
  +              (let ((a (first alist)))
  +                (when (reduce-action-p a)
  +                  (setf (aref reduction i) a)))))))
         (when (null muffle-conflicts) (setq muffle-conflicts '(0 0)))
         (unless (or (eq t muffle-conflicts)
                     (and (consp muffle-conflicts)
  
positive.code:   (do* ((i 0 (+ i 1)) (ps productions (cdr ps)) (p (car ps) (car ps)))
         ((null ps))
      (setf (production-id p) i))
    (%make-grammar :name name :terminals terminals :precedence precedence
                   :productions productions))
  
  (defun grammar-discard-memos (grammar)
    (setf (grammar-%symbols grammar) :undefined)
    (setf (grammar-derives-epsilon grammar) '())
    (setf (grammar-derives-first grammar) '())
    (setf (grammar-derives-first-terminal grammar) '()))
  
  (defun terminal-p (symbol grammar)
    (declare (symbol symbol) (type grammar grammar))
    (or (eq symbol 'propagate)
        (and (member symbol (grammar-terminals grammar)) t)))
  
  (defun grammar-symbols (grammar)
    "The set of symbols (both terminal and nonterminal) of GRAMMAR."
  
negative.code: 
  (defun derives-epsilon (symbol grammar &optional seen)
    "True if symbol derives epsilon."
    (declare #.standard-optimize-settings)
    (declare (symbol symbol) (type grammar grammar) (list seen))
    (multiple-value-bind (e present-p)
        (gethash symbol (grammar-derives-epsilon grammar))
      (cond
        (present-p e)
        ((terminal-p symbol grammar) nil)
        ((member symbol seen) nil)
        (t
         (let ((res (derives-epsilon* symbol grammar (cons symbol seen))))
           (when (or res (null seen))
             (setf (gethash symbol (grammar-derives-epsilon grammar)) res))
           res)))))
  
  (defun derives-epsilon* (symbol grammar &optional seen)
    "Unmemoised version of DERIVES-EPSILON."
    (declare #.standard-optimize-settings)
    (declare (symbol symbol) (type grammar grammar) (list seen))
    (dolist (production (grammar-productions grammar))
      (when (and (eq symbol (production-symbol production))
  