anchor.diff:                 (bss-size (+ (* control-stack-size 8)
                               (* data-stack-size 8)
                               (* binding-stack-size 8)))
  -               (image-size (- image-end load-base))
  +               (image-size (- support-end load-base))
                  (image (make-array (+ image-size #x1000) :element-type '(unsigned-byte 8)))
                  (object-values (make-hash-table)))
             (format t "Entry function MC size: ~D bytes~%" (length (genesis-function-assembled-code entry-function)))
  
positive.code:                                                               initial-stack-group entry-function
                                                                (mapcar 'cdr *function-preloads*)
                                                                (mapcar 'cdr *symbol-preloads*)))
        (multiple-value-bind (load-base phys-static-base phys-dynamic-base dynamic-end image-end initial-cr3 page-tables)
  	  (generate-physical-dump-layout static-size dynamic-size)
  	(let* ((control-stack-size 4096)
                 (data-stack-size 4096)
  
negative.code: 					   +page-table-present+
  					   +page-table-writable+))
        ;; Create the normal PML3.
        ;; Fourth entry is initially marked not-present.
        (dotimes (i 4)
  	(setf (aref page-tables 1 i) (logior (+ pml2-normal (* i #x1000))
  					     (if (= i 3) 0 +page-table-present+)
  					     +page-table-writable+)))
        (flet ((map-large-page (virt &optional phys)
  	       (multiple-value-bind (dir x)
  		   (truncate virt (* 1024 1024 1024))
                   (unless phys
                     (setf phys zero-fill-end)
                     (incf zero-fill-end #x200000))
  		 (let ((ofs (truncate x #x200000)))
  		   (setf (aref page-tables (+ 3 dir) ofs) (logior phys
  								  +page-table-present+
  								  +page-table-writable+
  								  +page-table-large+))))))
  	;; Map static space.
  	(dotimes (i (/ static-area-size #x200000))
  	  (map-large-page (+ *static-area-base* (* i #x200000))
  			  (+ static-base (* i #x200000))))
          (dotimes (i (/ (- static-area-full-size static-area-size) #x200000))
  	  (map-large-page (+ *static-area-base* static-area-size (* i #x200000))))
  	;; Map dynamic space A.
  	(dotimes (i (/ dynamic-area-size #x200000))
  	  (map-large-page (+ *dynamic-area-base* (* i #x200000))
  			  (+ dynamic-base (* i #x200000))))
          (dotimes (i (/ (- dynamic-area-full-size dynamic-area-size) #x200000))
  	  (map-large-page (+ *dynamic-area-base* dynamic-area-size (* i #x200000))))
          ;; Map dynamic space B.
          (dotimes (i (/ dynamic-area-size #x200000))
            (map-large-page (+ *dynamic-area-base* (* i #x200000) (/ *dynamic-area-size* 2)))))
        ;; Create the linear map PML3 and PML2s.
        (dotimes (i 4)
  	(setf (aref page-tables 2 i) (logior (+ pml2-linear (* i #x1000))
  