anchor.diff:  
   (defun action (old-state old-direction)
     ;; return a list of dotted list (state . direction)
  -  (remove nil
  -          (mapcar (lambda (direction)
  -                    (move-blank old-state direction))
  -                  (remove (case old-direction
  -                            (UP 'DOWN)
  -                            (DOWN 'UP)
  -                            (RIGHT 'LEFT)
  -                            (LEFT 'RIGHT))
  -                          '(UP DOWN RIGHT LEFT)))
  -          :key #'car))
  +  (let ((pos-0 (position 0 old-state)))
  +    (mapcar (lambda (direction)
  +              (move-blank old-state pos-0 direction))
  +            (remove (case old-direction
  +                      (UP 'DOWN)
  +                      (DOWN 'UP)
  +                      (RIGHT 'LEFT)
  +                      (LEFT 'RIGHT))
  +                    (aref '#((   RIGHT DOWN) (LEFT    RIGHT DOWN) (LEFT    DOWN)
  +                             (UP RIGHT DOWN) (LEFT UP RIGHT DOWN) (LEFT UP DOWN)
  +                             (UP RIGHT     ) (LEFT UP RIGHT     ) (LEFT UP     ))
  +                          pos-0)))))
   
   (defun n-puzzle (search heuristic initial-state)
     (funcall search #'action heuristic #'goalp initial-state))
  
positive.code:       (rotatef (aref temp-state i) (aref temp-state j))
        temp-state)))
  
  (defun move-blank (state direction)
    (declare (special *width*))
    (let ((pos-0 (position 0 state)))
      (cons (case direction
              (UP
               (let ((to (- pos-0 *width*)))
                 (when (>= to 0)
                   (swap state pos-0 to))))
              (DOWN
               (let ((to (+ pos-0 *width*)))
                 (when (< to (length state))
                   (swap state pos-0 to))))
              (LEFT
               (let ((to (1- pos-0)))
                 (unless (zerop (mod pos-0 *width*))
                   (swap state pos-0 to))))
              (RIGHT
               (let ((to (1+ pos-0)))
                 (unless (zerop (mod to *width*))
                   (swap state pos-0 to)))))
            direction)))
  
  (defparameter *width* 3)
  
  
negative.code: (defun fringe-insert (f items)
    (mapc (lambda (item)
            (let ((elements (fringe-elements f))
  		(hash-elements (fringe-hash-elements f))
  		(key (funcall (fringe-key f) item)))
              (loop while (<= (fill-pointer elements) key) do
                    (vector-push-extend nil elements))
              (push item (aref elements key))
  	    (push t (gethash item hash-elements))))
          items)
    f)
  
  (defstruct node
    (state nil :type vector)
    (parent nil)
    (direction nil :type symbol)
    (path-cost 0 :type integer)
    (depth 0 :type integer))
  
  (defun direction-sequence (node)
    (labels ((direction-sequence-iter (node directions)
  