anchor.diff:        ;; Update page tables and release pages if possible.
         (let ((pte (get-pte-for-address (+ base (* i #x1000)) nil)))
           (when (and pte (page-present-p pte 0))
  -          (cond ((or (not (logtest sys.int::+block-map-present+ flags))
  -                     (logtest sys.int::+block-map-zero-fill+ flags))
  +          (cond ((or (not (block-info-present-p flags))
  +                     (block-info-zero-fill-p flags))
                    ;; Page going away, but it's ok. It'll be back, zero-filled.
                    #+(or)(debug-print-line "  flush page " (+ base (* i #x1000)) "  " (page-table-entry pte 0))
                    (release-vm-page (ash (page-table-entry pte 0) -12))
                    (setf (page-table-entry pte 0) 0))
  -                ((logtest sys.int::+block-map-writable+ flags)
  +                ((block-info-writable-p flags)
                    ;; Mark writable.
                    (setf (page-table-entry pte 0) (logior (page-table-entry pte 0)
                                                           +page-table-write+)))
  
positive.code:       (when (and pte
                   (not (page-present-p pte 0))
                   block-info
                   (logtest sys.int::+block-map-present+ block-info)
                   (logtest sys.int::+block-map-zero-fill+ block-info))
          ;; Mapping a zero page into an existing PTE.
          (let ((frame (allocate-physical-pages 1 :type :active)))
            (when frame
              ;(debug-print-line "Zero page fast path for " fault-address)
              (let ((page-addr (+ +physical-map-base+ (ash frame 12))))
                (setf (physical-page-frame-block-id frame) (ldb (byte sys.int::+block-map-id-size+ sys.int::+block-map-id-shift+) block-info)
                      (physical-page-virtual-address frame) (logand fault-address (lognot (1- +4k-page-size+))))
                (append-to-page-replacement-list frame)
                (zeroize-page page-addr)
  
negative.code:               (zerop (sys.int::memref-unsigned-byte-64 bme-addr 0)))
        (panic "Block " address " entry is zero or not allocated!"))
      (let* ((bme (sys.int::memref-unsigned-byte-64 bme-addr 0))
             (block-id (block-info-block-id bme)))
        (cond ((block-info-committed-p bme)
               (store-free block-id 1))
              (t #+(or)(debug-print-line "Block " (sys.int::memref-unsigned-byte-64 bme-addr 0) " vaddr " address " is uncommitted.")
                 (store-deferred-free block-id 1)
  