anchor.diff:  
   (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))
  
positive.code:                  (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)))))))
  
  (defun IDA*-search (action heuristic goalp initial-state)
    (let ((max-cost-limit 105)
          (initial-node (make-node :state initial-state)))
      (labels ((expand (node)
                 (mapcar (lambda (state-direction)
                           (let ((state (car state-direction))
                                 (direction (cdr state-direction))
                                 (depth (1+ (node-depth node))))
                             (make-node :state state
                                        :parent node
                                        :direction direction
                                        :depth depth)))
                         (funcall action (node-state node) (node-direction node))))
               (search-iter (fringe cost-limit next-cost-limit)
                 (if (null fringe)
                     (search-iter (list initial-node) next-cost-limit max-cost-limit)
  
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))
  