anchor.diff:                      (incf (mark-charpos mark))))))))
     (values))
   
  -(defun forward-char (buffer &optional (n 1))
  +(defun move-char (buffer &optional (n 1))
     "Move point forward by N characters. Move backwards if N is negative."
     (move-mark (buffer-point buffer) n)
  -  (update-point-column-hint buffer)
     (values))
   
  -(defun backward-char (buffer &optional (n 1))
  -  (forward-char buffer (- n)))
  -
  -(defun forward-line (buffer &optional (n 1))
  +(defun move-line (buffer &optional (n 1))
     "Move point down by N lines. N may be negative.
   Tries to stay as close to the hint column as possible."
  -  (let ((accessor #'next-line)
  -        (point (buffer-point buffer)))
  +  (let* ((accessor #'next-line)
  +         (point (buffer-point buffer)))
  +    (when (not (eql *last-command* 'next-line))
  +      (setf (buffer-property buffer 'column-hint 0) (mark-charpos point)))
  +    (setf *this-command* 'next-line)
       (when (minusp n)
         (setf n (- n)
               accessor #'previous-line))
  
positive.code:     (let ((mark (copy-mark (buffer-point buffer) :left)))
        (dotimes (i (* (window-rows) 2))
          (dotimes (j width)
            (insert-char buffer (code-char (+ #x20 i))))
          (insert-line buffer))
        (point-to-mark buffer mark))))
  
  ;;; Mark stuff.
  
negative.code:         (point-to-mark buffer here))))
    (values))
  
  ;;; Point motion.
  
  (defun move-beginning-of-line (buffer)
    (setf (mark-charpos (buffer-point buffer)) 0)
    (values))
  
  (defun move-end-of-line (buffer)
    (let ((point (buffer-point buffer)))
      (setf (mark-charpos point) (line-length (mark-line point))))
    (values))
  
  (defun move-mark (mark &optional (n 1))
  