anchor.diff:    (cond ((not (subtask todo))
   	 (task todo))
   	(t
  -	 (when-let ((next (next-todo todo)))
  +	 (when-let ((next (first-todo todo)))
   	   (task next)))))
   
  -(defun next-todo (todo)
  -  (when (typep todo 'todo)
  -    (if (subtask todo)
  -	(do ()
  -	    ((not (subtask todo)) todo)
  -	  (setq todo (subtask todo)))
  -	(next todo))))
  +(defun first-todo (todo)
  +  (assert (typep todo 'todo))
  +  (do ()
  +      ((not (subtask todo)) todo)
  +    (setq todo (subtask todo))))
   
  -(defun locate (str todo)
  -  (labels ((dfs (node prev)
  -	     (when (task-prefix-p str node)    
  -	       (return-from locate (values node prev)))
  -	     (when-let ((subtask (subtask node)))
  -	       (multiple-value-bind (node prev) (dfs subtask node)
  -		 (when node
  -		   (return-from locate (values node prev)))))
  -	     (when-let ((next (next node)))
  -	       (multiple-value-bind (node prev) (dfs next node)
  -		 (when node
  -		   (return-from locate (values node prev)))))))
  -    (dfs todo nil)))
  +(defun locate (string todo)
  +  (labels ((dfs (stack)
  +	     (destructuring-bind (node prev first) (car stack)
  +	       (declare (ignorable prev))
  +	       (when (task-prefix-p string node)
  +		 (return-from locate stack))
  +	       (when-let ((subtask (subtask node)))
  +		 (dfs (cons (list subtask nil subtask) stack)))
  +	       (when-let ((next (next node)))
  +		 (dfs (cons (list next node first) (cdr stack)))))))
  +    (dfs (cons (list todo nil todo) nil))))
   
   (defvar *todo-pathname* (merge-pathnames
   			 (make-pathname :name "todo" :type "obj")
  
positive.code: ;;;; much-todo.lisp
  ;;; This file operates on a single todo file, todo.obj, located within
  ;;; the project's directory. The file is a textual representation of
  ;;; our todo items. We implement convenient ways to view the file,
  ;;; and add and remove items from the file, from the repl.
  
  ;;;; preamble
  
  
negative.code:   "Remove the first todo from the list."
    (with-todo todo
      (let ((top todo)
  	  (next (first-todo todo)))
        (if (subtask todo)
  	  (do ((subtask (subtask todo) (subtask subtask))
  	       (previous todo subtask))
  	      ((not (subtask subtask))
  	       (setf (subtask previous) (next next))
  	       (format t "~&Finished:~&~A" (task next))))
  	  (progn
  	    (setf todo (next todo))
  	    (format t "~&Finished:~&~A" (task top)))))))
  
  (defun nmove-to-front (string todo)
    "If string is a prefix for the task of a todo, move it to the front of todo."
    (when (task-prefix-p string todo)
      (return-from nmove-to-front todo))
    (let ((stack (locate string todo)))
      (unless stack (return-from nmove-to-front nil))
      (mapl (lambda (more)
  	    (destructuring-bind (looking prev first) (car more)
  	      (when prev
  		(setf (next prev) (next looking)
  		      (next looking) first))
  	      (unless (cdr more) (return-from nmove-to-front looking))
  	      (setf (subtask (first (cadr more))) looking)))
  	  stack)))
  
  (defun task-prefix-p (prefix target)
    (let ((task (task target)))
  