anchor.diff:                                             end)
                                          key))))
   
  -(defun next-single-property-change (marker property-name &optional limit-marker)
  -  (let ((first-value (text-property-at marker property-name))
  -        (start-marker (copy-point marker :temporary)))
  +(defun next-single-property-change (point property-name &optional limit-point)
  +  (let ((first-value (text-property-at point property-name))
  +        (start-point (copy-point point :temporary)))
       (loop
  -      (unless (character-offset marker 1)
  -        (move-point marker start-marker)
  +      (unless (character-offset point 1)
  +        (move-point point start-point)
           (return nil))
  -      (unless (eq first-value (text-property-at marker property-name))
  -        (return marker))
  -      (when (and limit-marker (point<= limit-marker marker))
  -        (move-point marker start-marker)
  +      (unless (eq first-value (text-property-at point property-name))
  +        (return point))
  +      (when (and limit-point (point<= limit-point point))
  +        (move-point point start-point)
           (return nil)))))
   
  -(defun previous-single-property-change (marker property-name &optional limit-marker)
  -  (let ((first-value (text-property-at marker property-name -1))
  -        (start-marker (copy-point marker :temporary)))
  +(defun previous-single-property-change (point property-name &optional limit-point)
  +  (let ((first-value (text-property-at point property-name -1))
  +        (start-point (copy-point point :temporary)))
       (loop
  -      (unless (eq first-value (text-property-at marker property-name -1))
  -        (return marker))
  -      (unless (character-offset marker -1)
  -        (move-point marker start-marker)
  +      (unless (eq first-value (text-property-at point property-name -1))
  +        (return point))
  +      (unless (character-offset point -1)
  +        (move-point point start-point)
           (return nil))
  -      (when (and limit-marker (point>= limit-marker marker))
  -        (move-point marker start-marker)
  +      (when (and limit-point (point>= limit-point point))
  +        (move-point point start-point)
           (return nil)))))
   
  -(defun line-string-at (marker)
  -  (buffer-line-string (point-buffer marker)
  -                      (point-linum marker)))
  -
  -(defun point-column (marker)
  -  (string-width (line-string-at marker)
  +(defun line-string-at (point)
  +  (buffer-line-string (point-buffer point)
  +                      (point-linum point)))
  +
  +(defun point-column (point)
  +  (string-width (line-string-at point)
                   0
  -                (point-charpos marker)))
  -
  -(defun move-to-column (marker column &optional force)
  -  (line-end marker)
  -  (let ((cur-column (point-column marker)))
  +                (point-charpos point)))
  +
  +(defun move-to-column (point column &optional force)
  +  (line-end point)
  +  (let ((cur-column (point-column point)))
       (cond ((< column cur-column)
  -           (setf (point-charpos marker)
  -                 (wide-index (line-string-at marker) column))
  -           marker)
  +           (setf (point-charpos point)
  +                 (wide-index (line-string-at point) column))
  +           point)
             (force
  -           (insert-char-at marker #\space (- column cur-column))
  -           (line-end marker))
  +           (insert-char-at point #\space (- column cur-column))
  +           (line-end point))
             (t
  -           (line-end marker)))))
  +           (line-end point)))))
   
   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   
positive.code:   (buffer-mark-cancel buffer)
    (delete-char/marker (buffer-point buffer) t))
  
  (defun text-property-at (marker key &optional (offset 0))
    (if (zerop offset)
        (line-search-property (get-line/marker marker) key (point-charpos marker))
        (with-point ((temp-marker marker))
          (when (character-offset temp-marker offset)
            (text-property-at temp-marker key 0)))))
  
  (defun put-text-property (start-marker end-marker key value)
    (assert (eq (point-buffer start-marker)
                (point-buffer end-marker)))
    (%map-region start-marker end-marker
                 (lambda (line start end)
                   (line-add-property line
                                      start
  
negative.code:                                     value
                                      (null end)))))
  
  (defun remove-text-property (start-point end-point key)
    (assert (eq (point-buffer start-point)
                (point-buffer end-point)))
    (%map-region start-point end-point
                 (lambda (line start end)
                   (line-remove-property line
                                         start
  