anchor.diff:                  while a
                   do (vector-push-extend (cons a b) cells))
             (da-clear-dirty da)
  -          da))))+          da))))
  
positive.code:   (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))
                       (< s (+ first-sym +da-pool-begin+)))
            do (setf s (- (da-get-check da s))))
      (when (= s (da-get-free-list da))
        (setf s (+ first-sym +da-pool-begin+))
        (loop do (da-extend-pool da s)
              if (minusp (da-get-check da s))
                do (loop-finish)
              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))))
      (- 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-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 old-next = (+ old-base sym)
          for new-next = (+ new-base sym)
          for old-next-base = (da-get-base da old-next)
  
negative.code:          (loop for i from base to (max-check-state-at-base da base)
                 thereis (= (da-get-check da i) s)))))
  
  (defun da-collect-c (da s c)
    "base[s] を遷移元とする c を集める。"
    (let* ((base (da-get-base da s))
           (cs (loop for i from base to (max-check-state-at-base da base)
                          if (= (da-get-check da i) s)
                            collect (- i base))))
      (sort (if c (cons c cs) cs)
            #'<=)))
  
  (defun da-get-state-key (da s)
  