anchor.diff:  
   (defconstant +freelist-metadata-size+ 32)
   
  +(defun store-refill-metadata ()
  +  ;; Repopulate freelist.
  +  (let* ((frame (let ((*store-freelist-recursive-metadata-allocation* t))
  +                  (pager-allocate-page :other)))
  +         (addr (+ +physical-map-base+ (ash frame 12))))
  +    (dotimes (i (truncate #x1000 +freelist-metadata-size+))
  +      (setf (sys.int::memref-unsigned-byte-64 (+ addr (* i +freelist-metadata-size+)) 0) 0
  +            (sys.int::memref-unsigned-byte-64 (+ addr (* i +freelist-metadata-size+)) 1) 0
  +            (sys.int::memref-unsigned-byte-64 (+ addr (* i +freelist-metadata-size+)) 2) 0
  +            (sys.int::memref-unsigned-byte-64 (+ addr (* i +freelist-metadata-size+)) 3) 0)
  +      (incf *store-freelist-n-free-metadata*)
  +      (setf (freelist-metadata-next (+ addr (* i +freelist-metadata-size+))) *store-freelist-metadata-freelist*
  +            *store-freelist-metadata-freelist* (+ addr (* i +freelist-metadata-size+))))))
  +
   (defun freelist-alloc-metadata (start end freep)
  -  (when (not *store-freelist-metadata-freelist*)
  -    ;; Repopulate freelist.
  -    ;; This allocation could potentially get exciting.
  -    ;; PAGER-ALLOCATE-PAGE doesn't call back into the store functions,
  -    ;; but if it does then this'll have to change.
  -    (let* ((frame (pager-allocate-page :other))
  -           (addr (+ +physical-map-base+ (ash frame 12))))
  -      (dotimes (i (truncate #x1000 +freelist-metadata-size+))
  -        (setf (sys.int::memref-unsigned-byte-64 (+ addr (* i +freelist-metadata-size+)) 0) 0
  -              (sys.int::memref-unsigned-byte-64 (+ addr (* i +freelist-metadata-size+)) 1) 0
  -              (sys.int::memref-unsigned-byte-64 (+ addr (* i +freelist-metadata-size+)) 2) 0
  -              (sys.int::memref-unsigned-byte-64 (+ addr (* i +freelist-metadata-size+)) 3) 0)
  -        (setf (freelist-metadata-next (+ addr (* i +freelist-metadata-size+))) *store-freelist-metadata-freelist*
  -              *store-freelist-metadata-freelist* (+ addr (* i +freelist-metadata-size+))))))
  +  (ensure *store-freelist-metadata-freelist* "No available freelist metadata objects!")
     (let ((new *store-freelist-metadata-freelist*))
       (setf *store-freelist-metadata-freelist* (freelist-metadata-next new))
       (setf (freelist-metadata-start new) start
  
positive.code: 
  (defun initialize-store-freelist (n-store-blocks freelist-block)
    (setf *store-freelist-metadata-freelist* '()
          *store-freelist-head* (freelist-alloc-metadata 0 n-store-blocks t)
          *store-freelist-tail* *store-freelist-head*
          *store-freelist-n-free-blocks* n-store-blocks
          *store-freelist-total-blocks* n-store-blocks)
  
negative.code:         (debug-print-line "Range: " (freelist-metadata-start range) "-" (freelist-metadata-end range) ":" (freelist-metadata-free-p range)))
        (return))))
  
  (defun store-free (start n-blocks)
    (ensure (mutex-held-p *vm-lock*) "*VM-LOCK* must be held when freeing store.")
    (store-maybe-refill-metadata)
    (incf *store-freelist-n-free-blocks* n-blocks)
    (store-insert-range start n-blocks t))
  
  (defun store-deferred-free (start n-blocks)
    (store-maybe-refill-metadata)
    (ensure (mutex-held-p *vm-lock*) "*VM-LOCK* must be held when freeing store.")
    (debug-print-line "Deferred store free " start " " n-blocks))
  
  (defun store-alloc (n-blocks)
    "Allocate from the in-memory freelist only. The freelist lock must be held."
    (ensure (mutex-held-p *vm-lock*) "*VM-LOCK* must be held when allocating store.")
    (store-maybe-refill-metadata)
    ;; Find a free range large enough.
    (do ((range *store-freelist-head* (freelist-metadata-next range)))
        ((null range)
  