anchor.diff:           (member?-impl in (node-sibling node)))))
   
   (defun member? (key trie)
  +  (declare #.*fastest*)
     (let ((in (byte-stream:make (string-to-octets key))))
       (member?-impl in (node-child trie))))
   
  
positive.code:     (unless (byte-stream:eos? in)
        (push-child (byte-stream:eat in) new-node))))
  
  (defun insert (in parent ch-memo si-memo)
    (declare #.*fastest*)
    (let ((node (node-child parent)))
      (if (or (null node)
              (/= (byte-stream:peek in) (node-label node)))
          (progn
            (setf (node-child parent) (memoize node ch-memo si-memo))
            (push-child in parent))
        (insert (byte-stream:eat in) node ch-memo si-memo))))
  
  (defun build-from-file (filepath)
    (declare #.*fastest*)
    (let* ((trie (make-node))
           (ch-memo (dict:make :test #'node= :hash #'sxhash-node))
           (si-memo (dict:make :test #'sibling= :hash #'sxhash-sibling))
           (cnt 0))
      (declare (fixnum cnt))
      (each-file-line-bytes (bytes beg end filepath)
        (when (zerop (mod (incf cnt) 5000))
          (print (list cnt)))
        (let ((in (byte-stream:make bytes :start beg :end end)))
          (declare (dynamic-extent in))
          (values (insert in trie ch-memo si-memo))))
      (setf trie (memoize trie ch-memo si-memo))
      trie))
  
  (defun member?-impl (in node)
    (cond ((null node) nil)
          ((= (byte-stream:peek in) (node-label node))
           (or (byte-stream:eos? in)
  
negative.code:   (label     0 :type octet)
    (sibling nil :type (or null node))
    (child   nil :type (or null node))
    (hash     -1 :type fixnum))
  
  (defun node= (n1 n2)
    (declare #.*fastest*)
    (and (= (node-label n1) (node-label n2))
         (eq (node-child n1) (node-child n2))
         (eq (node-sibling n1) (node-sibling n2))))
  
  (defun sxhash-node (node)
    (declare #.*fastest*)
    (if (null node)
        #.(sxhash nil)
      (with-slots (hash) (the node node)
        (when (= -1 hash)
          (setf hash (logxor (sxhash (node-label node))
                             (sxhash-node (node-child node))
                             (sxhash-node (node-sibling node)))))
        hash)))
  
  (defun memoize (node memo)
    (declare #.*fastest*)
    (if (null node)
        nil
      (or (dict:get node memo)
          (progn 
            (setf (node-child node) (memoize (node-child node) memo)
                  (node-sibling node) (memoize (node-sibling node) memo))
            (dict:get node memo))
          (setf (dict:get node memo) node))))
  
  (defun push-child (in parent)
    (declare #.*fastest*) 
  