anchor.diff:  (defun fringe-insert (f items)
     (mapc (lambda (item)
             (let ((elements (fringe-elements f))
  -                (key (funcall (fringe-key f) item)))
  +		(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 item (aref elements key))
  +	    (push t (gethash item hash-elements))))
           items)
     f)
   
   (defstruct node
  -  state
  +  (state nil :type vector)
     (parent nil)
  -  (direction nil)
  -  (path-cost 0)
  -  (depth 0))
  +  (direction nil :type symbol)
  +  (path-cost 0 :type integer)
  +  (depth 0 :type integer))
   
   (defun direction-sequence (node)
     (labels ((direction-sequence-iter (node directions)
  
positive.code:                    (debug 0)))
  
  (defstruct fringe
    (minimum 0)
    (key #'identity)
    (elements (make-array 1024 :fill-pointer 0 :adjustable t)))
  
  (defun fringe-existp (f item)
    (let ((elements (fringe-elements f))
          (key (funcall (fringe-key f) item)))
      ;; No need to consider case `key<minimum`
      (if (<= (fill-pointer elements) key)
          nil
        (member item (aref elements key)))))
  
  (defun fringe-remove (f)
    (let ((elements (fringe-elements f))
  	(minimum (fringe-minimum f)))
      (loop while (null (aref elements minimum)) do
            (incf minimum 1))
  
negative.code:       (rotatef (aref temp-state i) (aref temp-state j))
        temp-state)))
  
  (defun move-blank (state pos-0 direction)
    (declare (special *width*))
    (cons (swap state
                pos-0
                (case direction
                  (UP
                   (- pos-0 *width*))
                  (DOWN
                   (+ pos-0 *width*))
                  (LEFT
                   (1- pos-0))
                  (RIGHT
                   (1+ pos-0))))
          direction))
  
  (defparameter *width* 3)
  
  