anchor.diff:                     (debug 0)))
   
   (defstruct fringe
  +  (state #'identity :type function :read-only t)
  +  (key #'identity :type function :read-only t)
  +  (elements (make-array 1024 :fill-pointer 0 :adjustable t) :type array)
  +  ;; Shadow slots, only can be modified by #'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-exist-state-p (f state)
  +  (let ((hash-elements (fringe-hash-elements f)))
  +    (gethash state hash-elements)))
   
   (defun fringe-remove (f)
     (let ((elements (fringe-elements f))
  
positive.code:                             (LEFT 'RIGHT))
                            '(UP DOWN RIGHT LEFT))))))
  
  
  (defun n-puzzle (search heuristic initial-state)
    (funcall search #'action heuristic #'goalp initial-state))
  
  
negative.code:   (mapc (lambda (item)
            (let ((elements (fringe-elements f))
  		(hash-elements (fringe-hash-elements f))
  		(key (funcall (fringe-key f) item))
                  (state (funcall (fringe-state f) item)))
              (loop for i from (fill-pointer elements) to key do
                    (vector-push-extend nil elements))
              (push item (aref elements key))
  	    (push t (gethash state hash-elements))))
          items)
    f)
  
  