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:          (message "Macro not active"))
          (t
           (setq *macro-recording-p* nil)
           (setq *last-macro-chars* (nreverse *temp-macro-chars*))
           (message "End macro")
           t)))
  
  (defun execute-key-sequence (key-sequence)
    (let ((prev-unread-keys-length (length *unread-keys*)))
      (unread-key-sequence key-sequence)
      (do ()
          ((>= prev-unread-keys-length
               (length *unread-keys*))
           t)
        (handler-case (funcall (find-keybind (read-key-sequence)) nil)
          (editor-condition ()
            (setf *unread-keys* prev-unread-keys-length)
            (return nil))))))
  
  (define-key *global-keymap* (kbd "C-x e") 'execute-macro)
  (define-command execute-macro (n) ("p")
  