anchor.diff:    nil)
   
   
  -(defun frontier-fifo-to-pool (head tail)
  +(defun free-frontier-fifo (head tail)
     "Add a list of FRONTIERs to the free frontier pool.
   TAIL must be the last CONS cell of the list starting at HEAD."
     (declare (type cons head tail))
  
positive.code: 
  ;;;; ** free frontier pool
  
  (declaim (type list *frontier-pool* *cons-pool*))
  (defvar *frontier-pool* nil)
  (defvar *cons-pool* nil)
  
  (eval-when (:load-toplevel :execute)
    (dolist (sym '(*frontier-pool* *cons-pool*))
      (unless (assoc sym bt:*default-special-bindings* :test 'eq)
        (push (cons sym nil) bt:*default-special-bindings*))))
  
  (declaim (inline cons-from-pool
                   cons-to-pool
                   cons-and-frontier-from-pool
                   cons-and-frontier-to-pool
                   frontier-to-pool))
  
  (defun cons-from-pool ()
    "Get a CONS from free cons pool if available, and return it."
    (when-bind cell *cons-pool*
      (setf *cons-pool* (rest cell)
            (rest cell) nil)
      cell))
  
  (defun new-cons (&optional a b)
    "Get a CONS from free cons pool, otherwise allocate it. Return the CONS."
    (if-bind cell (cons-from-pool)
      (progn
        (setf (first cell) a
              (rest  cell) b)
        cell)
      (cons a b)))
  
  (defun cons-to-pool (cell)
    "Add a CONS cell to free cons pool.
  Note: (first cell) should be NIL."
    (declare (type cons cell))
    (setf (rest cell) *cons-pool*
          *cons-pool* cell)
    nil)
  
  
  (defun cons-and-frontier-from-pool ()
    "Get a CONS and a FRONTIER from pool if available, and return them."
    (block nil
      (when-bind cell *frontier-pool*
        (setf *frontier-pool* (rest cell)
              (rest cell) nil)
        (return cell))
      (awhen (cons-from-pool)
        (return it))))
  
  
  (defun cons-and-frontier-to-pool (cell)
    "Add (first cell) - which must be a FRONTIER - to the free frontier pool."
    (declare (type cons cell))
    (setf (rest cell) *frontier-pool*
  
negative.code:         (let1 f (first cell)
            (setf (frontier-fifo-head fifo) (rest cell)
                  (first cell) nil)
            (free-cons^ cell)
            (the frontier f)))))
  
  (defun clear-frontier-fifo (fifo)
  