anchor.diff:         :stream stream
          :count 100))))
   
  +(defun error-report (condition)
  +  (with-output-to-string (stream)
  +    (princ condition stream)
  +    (uiop/image:print-backtrace
  +     :stream stream
  +     :condition condition)))
  +
   (defun bailout (condition)
     (throw 'toplevel
  -    (with-output-to-string (stream)
  -      (princ condition stream)
  -      (uiop/image:print-backtrace
  -       :stream stream
  -       :condition condition))))
  +    (error-report condition)))
   
   (defmacro with-error-handler (() &body body)
     `(handler-case-bind ((lambda (condition)
  -                         (handler-bind ((error #'bailout))
  -                           (pop-up-backtrace condition)))
  +                         (if *debug-p*
  +                             (bailout condition)
  +                             (handler-bind ((error #'bailout))
  +                               (pop-up-backtrace condition))))
                          ,@body)
                         ((condition) (declare (ignore condition)))))
   
  
positive.code: 
  (let ((passed nil))
    (defun call-with-editor (function)
      (unwind-protect
          (catch 'toplevel
            (let ((*running-p* t))
              (unless passed
                (setq passed t)
                (let ((*debug-p* t))
                  (cockpit
                    (display-init)
                    (window-init)
                    (minibuf-init)
                    (setup)
                    (run-hooks *after-init-hook*))))
              (funcall function)))
        (display-finalize))))
  
  (defmacro with-editor (() &body body)
    `(call-with-editor (lambda () ,@body)))
  
  (defun check-init ()
    (when *running-p*
      (error "Editor is already running")))
  
  (defun lem (&rest args)
    (check-init)
    (let ((report (with-editor ()
                    (mapc 'find-file args)
                    (lem-internal))))
      (when report
        (format t "~&~a~%" report))))
  
negative.code:   (catch 'toplevel
      (do-commandloop (:toplevel t)
        (with-error-handler ()
          (when (= 0 (event-queue-length)) (redraw-display))
          (handler-case
              (handler-bind ((editor-condition
                              (lambda (c)
                                (declare (ignore c))
                                (stop-record-key))))
                (let ((cmd (read-key-command-with-idle-timers)))
                  (message nil)
                  (cmd-call cmd nil)))
            (editor-abort ()
                          (buffer-mark-cancel (current-buffer))
                          (message "Quit"))
            (editor-condition (c)
                              (message "~A" c)))))
      nil))
  
  (defun lem-internal ()
    (let* ((main-thread (bt:current-thread))
           (editor-thread (bt:make-thread
                           (lambda ()
                             (let* ((*in-the-editor* t)
                                    (result (toplevel-editor-loop)))
                               (bt:interrupt-thread main-thread
                                                    (lambda ()
                                                      (error 'exit-editor
  