anchor.diff:    (da-set-base da s new-base))
   
   (defun da-extend-pool (da to-index)
  -  (cond ((or (<= to-index 0)
  +  (cond ((< to-index (da-size da))
  +         da)
  +        ((or (<= to-index 0)
                (<= +trie-index-max+ to-index))
            (error 'da-extend-pool-error))
  -        ((< to-index (da-size da))
  -         da)
           (t
            (let ((new-begin (da-size da)))
              ;; initialize new free list
  
positive.code:                 while a
                  do (vector-push-extend (cons a b) cells))
            (da-clear-dirty da)
            da))))
negative.code:   (declare (ignore da))
    1)
  
  (defun da-find-free-base (da cs)
    (let* ((free-list (da-get-free-list da))
           (first-sym (car cs))
           (s (- (da-get-check da free-list))))
      (loop while (and (/= s free-list)
                       (< s (+ first-sym +da-pool-begin+)))
            do (setf s (- (da-get-check da s))))
      (when (= s free-list)
        (setf s (+ first-sym +da-pool-begin+))
        (loop do (da-extend-pool da s)
              until (minusp (da-get-check da s))
              do (incf s)))
      (loop until (da-fit-cs da (- s first-sym) cs)
            if (= (- (da-get-check da s)) free-list)
              do (da-extend-pool da (da-size da))
            do (setf s (- (da-get-check da s))))
      (- s first-sym)))
  
  (defun da-fit-cs (da base cs)
    (loop for sym in cs
          always (and (da-check-free-cell da (+ base sym))
                      (<= base (- +trie-index-max+ sym)))))
  
  (defun da-relocate-base (da s new-base)
    (loop with old-base = (da-get-base da s)
          for sym in (da-collect-c da s nil)
          for old-next = (+ old-base sym)
          for new-next = (+ new-base sym)
          for old-next-base = (da-get-base da old-next)
  