anchor.diff:    (mapc #'delete-overlay *isearch-highlight-overlays*)
     (setq *isearch-highlight-overlays* nil))
   
  -(defun isearch-update-buffer (marker &optional (search-string *isearch-string*))
  +(defun isearch-update-buffer (point &optional (search-string *isearch-string*))
     (isearch-reset-buffer)
     (unless (equal search-string "")
       (window-see (current-window))
  -    (lem::with-point ((cur-marker (lem::window-view-point (current-window)))
  -                       (limit-marker (or (lem::line-offset
  -                                          (copy-point (lem::window-view-point (current-window))
  -                                                       :temporary)
  -                                          (window-height (current-window)))
  -                                         (lem::buffers-end (window-buffer (current-window))))))
  +    (lem::with-point ((cur-point (lem::window-view-point (current-window)))
  +                      (limit-point (or (lem::line-offset
  +                                        (copy-point (lem::window-view-point (current-window))
  +                                                    :temporary)
  +                                        (window-height (current-window)))
  +                                       (lem::buffers-end (window-buffer (current-window))))))
         (loop :while (funcall *isearch-search-forward-function*
  -                            cur-marker
  +                            cur-point
                               search-string
  -                            limit-marker)
  -            :do (let ((start-marker (lem::with-point ((temp-marker cur-marker :temporary))
  -                                      (funcall *isearch-search-backward-function*
  -                                               temp-marker
  -                                               search-string)
  -                                      temp-marker)))
  -                  (push (make-overlay start-marker
  -                                      (copy-point cur-marker :temporary)
  -                                      (if (and (point<= start-marker marker)
  -                                               (point<= marker cur-marker))
  +                            limit-point)
  +            :do (let ((start-point (lem::with-point ((temp-point cur-point :temporary))
  +                                     (funcall *isearch-search-backward-function*
  +                                              temp-point
  +                                              search-string)
  +                                     temp-point)))
  +                  (push (make-overlay start-point
  +                                      (copy-point cur-point :temporary)
  +                                      (if (and (point<= start-point point)
  +                                               (point<= point cur-point))
                                             *isearch-highlight-active-attribute*
                                             *isearch-highlight-attribute*))
                           *isearch-highlight-overlays*))))))
  
positive.code:             (buffer (current-buffer)))
          (when (and before after)
            (if (buffer-mark-p buffer)
                (lem::with-point ((mark-marker (lem::buffer-mark buffer) :right-inserting))
                  (if (point< mark-marker (lem::buffer-point buffer))
                      (query-replace-internal-body mark-marker
                                                   (lem::buffer-point buffer)
                                                   before after)
                      (query-replace-internal-body (lem::buffer-point buffer)
                                                   mark-marker
                                                   before after)))
                (query-replace-internal-body (lem::buffer-point buffer)
                                             nil
  
negative.code: (define-command isearch-backward () ()
    (isearch-start
     "ISearch:"
     (lambda (point str)
       (search-backward (or (lem::character-offset point (length str))
                            point)
                        str))
     #'search-forward
     #'search-backward
  