anchor.diff:    (nlet recur ((node (get-node dawg 0)) (id -1))
       (if (stream:eos? in)
           (and (terminal? node) (inc-id id dawg node))
  -      (when (check-encoded-children in node)
  -        (let* ((arc (stream:read in))
  +      (when (check-encoded-children in node dawg)
  +        (let* ((arc (arc (stream:read in) dawg))
                  (next (get-node dawg (+ (base node) arc))))
             (when (= (chck next) arc)
               (recur next (inc-id id dawg node))))))))
  -
  -(defun each-common-prefix-impl (fn in dawg)
  -  (nlet recur ((node (get-node dawg 0)) (id -1))
  -    (when (terminal? node)
  -      (funcall fn (inc-id id dawg node) (stream:position in)))
  -    (unless (stream:eos? in)
  -      (when (check-encoded-children in node)
  -        (let* ((arc (stream:read in))
  -               (next (get-node dawg (+ (base node) arc))))
  -          (when (= (chck next) arc)
  -            (recur next (inc-id id dawg node))))))))
  -
  -(defun traverse-descendant (fn dawg node id)
  -  (declare #.*fastest*
  -           (function fn)
  -           (dawg dawg)
  -           (uint8 node)
  -           (fixnum id))
  -  (when (terminal? node)
  -    (funcall fn (inc-id id dawg node)))
  -  (loop FOR arc FROM 1 BELOW +ARC_LIMIT+ 
  -        FOR next OF-TYPE uint8 = (get-node dawg (+ (base node) arc))
  -        WHEN (= (chck next) arc)
  -      DO
  -      (traverse-descendant fn dawg next (inc-id id dawg node))))
  -
  -(defun each-predictive-impl (fn in dawg)
  -  (nlet recur ((node (get-node dawg 0)) (id -1))
  -    (declare (fixnum id))
  -    (if (stream:eos? in)
  -        (traverse-descendant fn dawg node id)
  -      (when (check-encoded-children in node)
  -        (let* ((arc (stream:read in))
  -               (next (get-node dawg (+ (base node) arc))))
  -          (when (= (chck next) arc)
  -            (recur next (inc-id id dawg node))))))))
  -
   
   (defmacro with-key-stream ((in key &key start end) &body body)
     (let ((k (gensym))
  
positive.code:   (with-key-stream (in key :start start :end end)
      (get-id-impl in dawg)))
  
  (defmacro each-common-prefix ((match-id match-end)
                                (key dawg &key (start 0) (end `(length ,key)))
                                &body body)
    (let ((in (gensym)))
      `(block nil
         (with-key-stream (,in ,key :start ,start :end ,end)
           (each-common-prefix-impl 
            (lambda (,match-id ,match-end)
              (declare (positive-fixnum ,match-id)
                       (array-index ,match-end))
              ,@body)
            ,in ,dawg))
         t)))
  
  (defmacro each-predictive ((match-id)
                             (key dawg &key (start 0) (end `(length ,key)))
                             &body body)
    (let ((in (gensym)))
      `(block nil
         (with-key-stream (,in ,key :start ,start :end ,end)
           (each-predictive-impl 
            (lambda (,match-id)
              (declare (positive-fixnum ,match-id))
              ,@body)
            ,in ,dawg))
         t)))
  
  
  (package-alias :dawg.octet-stream)
  
negative.code:            build
             load
             member?
             get-id))
  (in-package :dawg)
  
  (package-alias :dawg.octet-stream :stream)
  
  (deftype uint5 () '(unsigned-byte 40))
  
  ;;;;;;;;;;;;;;;;;;;;
  ;;; special variable
  