anchor.diff:            ((not line))
           (write-sequence (data line) s)
           (terpri s)))
  -    (setf (buffer-modified buffer) nil)))
  +    (setf (buffer-property buffer 'new-file) nil
  +          (buffer-modified buffer) nil)))
   
   (defun list-buffers-command ()
     (let ((buffer (get-buffer-create "*Buffers*")))
  
positive.code: 
  (defun find-file-command ()
    (let* ((path (read-from-minibuffer (format nil "Find file (default ~S): " *default-pathname-defaults*)))
           (filespec (merge-pathnames path)))
      (with-open-file (s filespec)
        (let* ((buffer (make-instance 'buffer))
               (start (copy-mark (buffer-point buffer) :left)))
          (loop
             (multiple-value-bind (line missing-newline-p)
                 (read-line s nil)
               (when (not line)
                 (return))
               (insert buffer line)
               (when (not missing-newline-p)
                 (insert buffer #\Newline))))
          (push buffer (buffer-list *editor*))
          (setf (buffer-property buffer 'path) filespec)
          (rename-buffer buffer (file-namestring s))
          (point-to-mark buffer start)
          ;; Loading the file will set the modified flag.
          (setf (buffer-modified buffer) nil)
          (switch-to-buffer buffer)))
      (setf *default-pathname-defaults* filespec)))
  
  (defun save-buffer-command ()
  
negative.code:               (t (return))))))
    (values))
  
  (defun character-right-of (mark)
    (cond ((eql (mark-charpos mark) (line-length (mark-line mark)))
           (cond
             ((next-line (mark-line mark))
              ;; At end of line.
              #\Newline)
             (t ;; At end of buffer.
              nil)))
          (t (line-character (mark-line mark) (mark-charpos mark)))))
  
  (defun character-left-of (mark)
    (cond ((eql (mark-charpos mark) 0)
           (cond
             ((previous-line (mark-line mark))
              ;; At start of line.
              #\Newline)
             (t ;; At start of buffer.
              nil)))
          (t (line-character (mark-line mark) (1- (mark-charpos mark))))))
  
  (defun scan (mark predicate jump key)
    (loop
       (let ((ch (funcall key mark)))
         (when (not ch)
           (return nil))
         (when (funcall predicate ch)
           (return t))
         (when (not (move-mark mark jump))
           (return nil)))))
  
  (defun scan-forward (mark predicate)
    (scan mark predicate 1 #'character-right-of))
  
  (defun scan-backward (mark predicate)
    (scan mark predicate -1 #'character-left-of))
  
  (defun move-word (buffer &optional (n 1))
    "Move point forward by N words. N may be negative."
  