anchor.diff:                                         :if-exists :supersede
                                          :direction :output)
             (write-llf-header output-stream input-file)
  -
             (let ((*llf-dry-run* nil))
               (dolist (cmd commands)
                 (dolist (o (cdr cmd))
  
positive.code:                omap stream)
    (write-byte +llf-instance-header+ stream))
  
  (defmethod save-one-object (object omap stream)
    ;; Use COMPILE-LAMBDA here instead of COMPILE to get the correct L-T-V behaviour.
    (let ((mezzano.compiler::*load-time-value-hook*
           (lambda (form read-only-p)
             (declare (ignore read-only-p))
             (let ((ltv-sym (gensym "LOAD-TIME-VALUE-CELL")))
               (save-object (mezzano.compiler::compile-lambda
                             `(lambda ()
                                (declare (special ,ltv-sym))
                                (setq ,ltv-sym ,form))
                             nil)
                            omap stream)
               (save-object 0 omap stream)
               (write-byte +llf-funcall-n+ stream)
               (write-byte +llf-drop+ stream)
               `(sys.int::symbol-global-value ',ltv-sym)))))
      (multiple-value-bind (creation-form initialization-form)
          (make-load-form object)
        (save-object (mezzano.compiler::compile-lambda
                      `(lambda ()
                         (declare (sys.int::lambda-name creation-form))
                         (progn ,creation-form))
                      nil)
                     omap stream)
        (save-object 0 omap stream)
        (write-byte +llf-funcall-n+ stream)
        (when initialization-form
          (write-object-backlink object omap stream)
          (save-object (mezzano.compiler::compile-lambda
                        `(lambda ()
                           (declare (sys.int::lambda-name initialization-form))
                           (progn ,initialization-form))
                        nil)
                       omap stream)
          (save-object 0 omap stream)
          (write-byte +llf-funcall-n+ stream)
          (write-byte +llf-drop+ stream)))))
  
  (defun write-object-backlink (object omap stream)
    (when (not *llf-dry-run*)
  
negative.code:   (if (and *compile-parallel*
             ;; If true, then this is a worker thread compiling something.
             ;; Don't schedule more work, just do it here.
             (not *current-deferred-function*)
             ;; If true then a make-load-form is actively being compiled
             ;; and is running in the context of save-object, now long past
             ;; the time that parallel compilation can be done.
             (not *compiling-make-load-form*))
        (let ((fn (make-instance 'deferred-function
                                 :ast (mezzano.compiler::pass1-lambda lambda env)
                                 :tlf-number *top-level-form-number*)))
  