anchor.diff:    (let ((base (da-get-base da state)))
       (if (< base 0)
           (funcall fun (da-get-state-key da state) state user-data)
  -        (loop for sym in (da-output-symbols da state nil)
  +        (loop for sym in (da-collect-c da state nil)
                 always(da-enumerate-recursive da (+ base sym) fun user-data)))))
   
   
  
positive.code:          (loop for i from base to (max-check-state-at-base da base)
                 thereis (= (da-get-check da i) s)))))
  
  (defun da-output-symbols (da s c)
    "base[s] を遷移元とする c を集める。"
    (let* ((base (da-get-base da s))
           (symbols (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 symbols) symbols)
            #'<=)))
  
  (defun da-get-state-key (da s)
  
negative.code:             (return-from da-insert-branch next))
            (when (or (> (+ base c) +trie-index-max+)
                      (not (da-check-free-cell da next)))
              (let* ((cs (da-collect-c da s c))
                     (new-base (da-find-free-base da cs)))
                (da-relocate-base da s new-base)
                (setf next (+ new-base c)))))
          (let ((new-base (da-find-free-base da (list c))))
  