anchor.diff:    )
   
   (defmethod trivial-gray-streams:stream-peek-char ((stream buffer-input-stream))
  -  (character-at (buffer-stream-marker stream)))
  +  (character-at (buffer-stream-point stream)))
   
   (defmethod trivial-gray-streams:stream-listen ((stream buffer-input-stream))
  -  (end-buffer-p (buffer-stream-marker stream)))
  +  (end-buffer-p (buffer-stream-point stream)))
   
   (defmethod trivial-gray-streams:stream-read-line ((stream buffer-input-stream))
  -  (let ((start (copy-point (buffer-stream-marker stream) :temporary)))
  +  (let ((start (copy-point (buffer-stream-point stream) :temporary)))
       (let ((string (points-to-string
                      start
  -                   (line-end (buffer-stream-marker stream)))))
  +                   (line-end (buffer-stream-point stream)))))
         (values string
  -              (not (line-offset (buffer-stream-marker stream) 1))))))
  +              (not (line-offset (buffer-stream-point stream) 1))))))
   
   (defmethod trivial-gray-streams:stream-clear-input ((stream buffer-input-stream))
     nil)
  
positive.code:   ((interactive-update-p
      :initarg :interactive-update-p
      :accessor buffer-output-stream-interactive-update-p)
     (marker
      :initarg :marker
      :accessor buffer-stream-marker)))
  
  (defun make-buffer-stream-instance (class-name marker
                                                 &optional
                                                 interactive-update-p)
    (make-instance class-name
                   :marker (copy-point marker :left-inserting)
                   :interactive-update-p interactive-update-p))
  
  (defun make-buffer-output-stream (&optional (marker (current-point))
                                              interactive-update-p)
    (make-buffer-stream-instance 'buffer-output-stream
                                 marker interactive-update-p))
  
  (defmethod trivial-gray-streams::close ((stream buffer-output-stream) &key abort)
    (declare (ignore abort))
    (delete-point (buffer-stream-marker stream))
    t)
  
  (defmethod stream-element-type ((stream buffer-output-stream))
    'line)
  
  (defmethod trivial-gray-streams:stream-line-column ((stream buffer-output-stream))
    (point-charpos (buffer-stream-marker stream)))
  
  (defun buffer-output-stream-refresh (stream)
    (when (buffer-output-stream-interactive-update-p stream)
      (let ((buffer (point-buffer (buffer-stream-marker stream)))
            (point (buffer-stream-marker stream)))
        (display-buffer buffer)
        (dolist (window (get-buffer-windows buffer))
          (move-point (buffer-point (window-buffer window)) point))
  
negative.code: 
  (defmethod trivial-gray-streams:stream-write-char ((stream buffer-output-stream) char)
    (prog1 char
      (insert-char/point (buffer-stream-point stream)
                          char)))
  
  (defun %write-string-to-buffer-stream (stream string start end &key)
    (insert-string/point (buffer-stream-point stream)
                          (subseq string start end))
    string)
  
  