anchor.diff:    (declare (ignore da))
     1)
   
  -(defun da-find-free-base (da symbols)
  -  (let ((first-sym (car symbols))
  -        (s (- (da-get-check da (da-get-free-list da)))))
  -    (loop while (and (/= s (da-get-free-list da))
  +(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 (da-get-free-list da))
  +    (when (= s free-list)
         (setf s (+ first-sym +da-pool-begin+))
         (loop do (da-extend-pool da s)
  -            if (minusp (da-get-check da s))
  -              do (loop-finish)
  +            until (minusp (da-get-check da s))
               do (incf s)))
  -    (loop until (da-fit-symbols da (- s first-sym) symbols)
  -          do (if (= (- (da-get-check da s)) (da-get-free-list da))
  -                 (da-extend-pool da (da-size da)))
  -             (setf s (- (da-get-check da 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-symbols (da base symbols)
  -  (not (loop for sym in symbols
  -             thereis (or (> base (- +trie-index-max+ sym))
  -                         (not (da-check-free-cell da (+ base 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-output-symbols da s nil)
  +        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)
  
positive.code:     next))
  
  (defun da-check-free-cell (da s)
    (and (da-extend-pool da s)
         (minusp (da-get-check da s))))
  
  (defun max-check-state-at-base (da base)
    (min (+ base +trie-char-max+) (1- (da-size da))))
  
negative.code:   (da-set-base da s new-base))
  
  (defun da-extend-pool (da to-index)
    (cond ((< to-index (da-size da))
           da)
          ((or (<= to-index 0)
               (<= +trie-index-max+ to-index))
           (error 'da-extend-pool-error))
          (t
           (let ((new-begin (da-size da)))
             ;; initialize new free list
  