anchor.diff:    (key #'identity)
     (elements (make-heap)))
   
  -(defun fringe-remove (q)
  -  (heap-pop (fringe-elements q) (fringe-key q)))
  -
  -(defun fringe-insert (q items)
  +(defun fringe-remove (f)
  +  (heap-pop (fringe-elements f) (fringe-key f)))
  +
  +(defun fringe-insert (f items)
     (mapc (lambda (item)
  -          (heap-insert (fringe-elements q) item (fringe-key q)))
  +          (heap-insert (fringe-elements f) item (fringe-key f)))
           items)
  -  q)
  +  f)
  +
  +(defun fringe-find (f key-val)
  +  (heap-find (fringe-elements f) key-val (fringe-key f)))
   
   (defstruct node
     state
  
positive.code:                                     :path-cost (+ depth cost)
                                      :depth (1+ depth))))
                       (remove-if (lambda (temp-triple)
                                    (find (aref temp-triple 1) (fringe-elements fringe) :key #'node-state :test #'equal))
                                  (mapcar (lambda (state-direction)
                                            (let ((state (car state-direction))
                                                  (direction (cdr state-direction)))
  
negative.code: (defun n-puzzle (search heuristic initial-state)
    (funcall search #'action heuristic #'goalp initial-state))
  
  (format t "IDA*-search~%")
  (time (format t "~A~%" (n-puzzle #'IDA*-search
                                   #'manhattan
                                   *start*)))
  
  (format t "A*-search~%")
  (time (format t "~A~%" (n-puzzle #'A*-search
                                   #'manhattan
                                   *start*)))
  