anchor.diff:          (t
            (let ((*macro-running-p* t))
              (loop
  -             :named outer
                :repeat n
  -             :while *macro-running-p*
  -             :do (let ((length (length *unread-keys*)))
  -                   (mapc 'input-enqueue (reverse *macro-chars*))
  -                   (loop :while (< length (length *unread-keys*)) :do
  -                     (unless *macro-running-p*
  -                       (loop :while (< length (length *unread-keys*))
  -                             :do (read-key))
  -                       (return-from outer nil))
  -                     (handler-case (funcall (find-keybind (read-key-sequence)) nil)
  -                       (editor-condition ()
  -                         (setf *unread-keys* nil)
  -                         (return-from outer nil)))))
  -             :finally (return-from outer t))))))
  +             :while (execute-key-sequence *last-macro-chars*)
  +             :finally (return t))))))
   
   (define-command apply-macro-to-region-lines () ()
     (apply-region-lines (region-beginning)
  
positive.code:         (t
           (message "Start macro")
           (setq *macro-recording-p* t)
           (setq *macro-chars* nil)
           t)))
  
  (define-key *global-keymap* (kbd "C-x )") 'end-macro)
  
negative.code:                   (get-char nil)
                    (pop *unread-keys*))))
      (when *macro-recording-p*
        (push char *temp-macro-chars*))
      char))
  
  (defun unread-key (char)
    (when *macro-recording-p*
      (pop *temp-macro-chars*))
    (push char *unread-keys*))
  
  (defun input-enqueue (c)
  