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: (defun n-puzzle (search heuristic initial-state)
    (funcall search #'action heuristic #'goalp initial-state))
  
  (format t "A*-search~%")
  (time (format t "~A~%" (n-puzzle #'IDA*-search
                                   #'manhattan
                                   *start*)))
  
  (format t "IDA*-search~%")
  (time (format t "~A~%" (n-puzzle #'A*-search
                                   #'manhattan
                                   *start*)))
  
negative.code:                                   key))
  	item))
  
  (defun heap-find (heap val key)
    (labels ((heap-find-iter (i)
               (let ((i-val (heap-val heap i key)))
                 (cond
                  ((= i-val val)
                   (aref heap i))
                  ((or (> i-val val)
                       (heap-leafp heap i))
                   nil)
                  (t
                   (let ((find-left (heap-find-iter (heap-left i))))
                     (if (null find-left)
                         (let ((find-right (heap-find-iter (heap-right i))))
                           (if (null find-right)
                               nil
                             find-right))
                       find-left)))))))
      (heap-find-iter 0)))
  
  (defun make-heap (&optional (size 1024))
    (make-array size
                :fill-pointer 0
  