anchor.diff:    (label     0 :type octet)
     (sibling nil :type (or null node))
     (child   nil :type (or null node))
  -  (hash     -1 :type fixnum))
  +  (hash     -1 :type fixnum)
  +  (hash-sib -1 :type fixnum))
  +
  +(defun node= (n1 n2)
  +  (declare #.*fastest*)
  +  (and (= (node-label n1) (node-label n2))
  +       (eq (node-child n1) (node-child 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)))))
  +      hash)))
  +
  +(defun sibling= (n1 n2)
  +  (declare #.*fastest*)
  +  (and (= (node-label n1) (node-label n2))
  +       (eq (node-sibling n1) (node-sibling n2))))
  +
  +(defun sxhash-sibling (node)
  +  (declare #.*fastest*)
  +  (if (null node)
  +      (sxhash nil)
  +    (with-slots (hash-sib) (the node node)
  +      (when (= -1 hash-sib)
  +        (setf hash-sib (logxor (sxhash (node-label node))
  +                               (sxhash-sibling (node-sibling node)))))
  +      hash-sib)))
  +
  +(defun memoize (node ch-memo si-memo)
  +  (if (null node)
  +      nil
  +    (or (dict:get node ch-memo)
  +        (progn (setf (node-child node) (memoize (node-child node) ch-memo si-memo))
  +               (dict:get node ch-memo))
  +        (setf (dict:get node ch-memo) node))))
   
   (defun push-child (in parent)
     (declare #.*fastest*) 
  
positive.code:     (unless (byte-stream:eos? in)
        (push-child (byte-stream:eat in) new-node))))
  
  (defun insert (in parent)
    (declare #.*fastest*)
    (let ((node (node-child parent)))
      (if (or (null node)
              (/= (byte-stream:peek in) (node-label node)))
          (push-child in parent)
        (insert (byte-stream:eat in) node))))
  
  (defun build-from-file (filepath)
    (declare #.*fastest*)
    (let* ((trie (make-node))
           (cnt 0))
      (declare (fixnum cnt))
      (each-file-line-bytes (bytes beg end filepath)
  
negative.code:         (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)
               (member?-impl (byte-stream:eat in) (node-child node))))
          ((< (byte-stream:peek in) (node-label node))
           (member?-impl in (node-sibling node)))))
  
  (defun member? (key trie)
    (let ((in (byte-stream:make (string-to-octets key))))
      (member?-impl in (node-child trie))))
  
  (defun node-count-impl (node memo)
    (when (and node (not (gethash node memo)))
  