anchor.diff:                   (search-iter (fringe-insert fringe (expand node fringe)))))))
       (search-iter (fringe-insert (make-fringe :key #'node-path-cost)
                                   (list (make-node :state initial-state
  -                                                 :path-cost (funcall heuristic initial-state)))))))
  +                                                 :path-cost (funcall heuristic initial-state)
  +                                                 :pos-0 (position 0 initial-state)))))))
   
   (defun IDA*-search (action heuristic goalp initial-state)
     (let ((max-cost-limit 105)
  -        (initial-node (make-node :state initial-state)))
  +        (initial-node (make-node :state initial-state
  +                                 :pos-0 (position 0 initial-state))))
       (labels ((expand (node)
  -               (mapcar (lambda (state-direction)
  -                         (let ((state (car state-direction))
  -                               (direction (cdr state-direction))
  -                               (depth (1+ (node-depth node))))
  +               (mapcar (lambda (triple)
  +                         (let ((state (aref triple 0))
  +                               (direction (aref triple 1))
  +                               (depth (1+ (node-depth node)))
  +                               (pos-0 (aref triple 2)))
                              (make-node :state state
                                         :parent node
                                         :direction direction
  -                                      :depth depth)))
  -                       (funcall action (node-state node) (node-direction node))))
  +                                      :depth depth
  +                                      :pos-0 pos-0)))
  +                       (funcall action node)))
                (search-iter (fringe cost-limit next-cost-limit)
                  (if (null fringe)
                      (search-iter (list initial-node) next-cost-limit max-cost-limit)
  
positive.code: 
  (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*)))
  
negative.code:   (labels ((expand (node fringe)
               (remove-if (lambda (new-node)
                            (fringe-existp fringe new-node))
                          (mapcar (lambda (triple)
                                    (let* ((state (aref triple 0))
                                           (direction (aref triple 1))
                                           (cost (funcall heuristic state))
                                           (depth (1+ (node-depth node)))
                                           (pos-0 (aref triple 2)))
                                      (make-node :state state
                                                 :parent node
                                                 :direction direction
                                                 :path-cost (+ depth cost)
                                                 :depth depth
                                                 :pos-0 pos-0)))
                                  (funcall action node))))
             (search-iter (fringe)
               (let ((node (fringe-remove fringe)))
                 (if (funcall goalp (node-state node))
  