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: 
  (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))
  
  (defun n-puzzle (search heuristic initial-state)
    (funcall search #'action heuristic #'goalp initial-state))
  
negative.code:                    (debug 0)))
  
  (defstruct fringe
    (minimum 0 :type integer)
    (key #'identity :type function)
    (elements (make-array 1024 :fill-pointer 0 :adjustable t) :type array)
    (hash-elements (make-hash-table)))
  
  (defun fringe-existp (f item)
    (let ((elements (fringe-elements f))
  	(hash-elements (fringe-hash-elements f))
          (key (funcall (fringe-key f) item)))
      ;; No need to consider case `key<minimum`
      (unless (<= (fill-pointer elements) key)
        (gethash item hash-elements))))
  
  (defun fringe-remove (f)
    (let ((elements (fringe-elements f))
  	(hash-elements (fringe-hash-elements f))
  	(minimum (fringe-minimum f)))
      (loop while (null (aref elements minimum)) do
            (incf minimum 1))
  