anchor.diff:                          0)))) )
   
   (defun build-search-node ()
  -  (cons (cons 1 1) 0))
  +  (cons 0 (cons (cons 1 1) 0)))
   
   (defun build-demo-world ()
     (cons (build-map)
  
positive.code:   ;; might return a new stack, or the same old stack
    ;; if the specified direction from the current search node has not been seen,
    ;; and is not a wall, add it to the stack.
    (if (and (location-not-in-seen (car node) seen)
             (and
                 (< (length (cdr node)) depth)
                 (not (iswall map-tree width treedepth
                                     (car (car node))
                                     (cdr (car node))))))
        ;; true case: return a new queue where we've added a new search node.
        (cons node stack)
        ;; false case: skip it and give back the same stack
        stack))
  
  (defun newsearchnode (oldnode direction)
    ;; search nodes are (cons LOCATION PATH)
    (cons (cons (+ (directiondx direction) (car (car oldnode)))
                (+ (directiondy direction) (cdr (car oldnode))))
          (append (cdr oldnode) direction)))
  
  ;; so we really want to be like ...
  ;; get a thing from the queue. if it's a winner, return the path!
  ;; for each possible direction from that thing, if it's not in the seen
  ;; list or a wall, enqueue it.
  ;; search states are represented as (cons LOCATION PATH)
  ;; ... where PATH is a proper list containing the list of directions for
  ;; getting there from the location we're searching from.
  
  (defun dfs-to-depth (depth stack seen map-tree width treedepth)
    (if (atom stack)
        0 ;;; 999
        (if (search-node-is-dot (car stack) map-tree width treedepth)
            (cdr (car stack))
            (dfs-to-depth
              depth
              (maybe-cons (newsearchnode (car stack) 0)
                          map-tree width treedepth 
                          depth (cons (car (car stack)) seen)
                (maybe-cons (newsearchnode (car stack) 1)
                            map-tree width treedepth 
                            depth (cons (car (car stack)) seen)
                  (maybe-cons (newsearchnode (car stack) 2)
                              map-tree width treedepth 
                              depth (cons (car (car stack)) seen)
                    (maybe-cons (newsearchnode (car stack) 3)
                                map-tree width treedepth 
                                depth (cons (car (car stack)) seen)
                      (cdr stack)))))
              (cons (car (car stack)) seen)
              map-tree
              width
              treedepth))))
  
negative.code: 
  (defun search-node-is-dot (searchnode map-tree width treedepth)
    (member
      (map-tree-lookup (car (car (cdr searchnode)))
                       (cdr (car (cdr searchnode)))
                       map-tree
                       width
                       treedepth)
  