anchor.diff:    (label     0 :type octet)
     (sibling nil :type (or null node))
     (child   nil :type (or null node))
  -  (hash     -1 :type fixnum)
  -  (hash-sib -1 :type fixnum))
  +  (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-child n1) (node-child n2))
  +       (eq (node-sibling n1) (node-sibling n2))))
   
   (defun sxhash-node (node)
     (declare #.*fastest*)
     (if (null node)
  -      (sxhash nil)
  +      #.(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-child node))
  +                           (sxhash-node (node-sibling 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)
  +(defun memoize (node memo)
     (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))))
  +    (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*) 
  
positive.code:          (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))))
  
  
negative.code:     (unless (byte-stream:eos? in)
        (push-child (byte-stream:eat in) new-node))))
  
  (defun insert (in parent 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 memo))
            (push-child in parent))
        (insert (byte-stream:eat in) node memo))))
  
  (defun build-from-file (filepath)
    (declare #.*fastest*)
    (let* ((trie (make-node))
           (memo (dict:make :test #'node= :hash #'sxhash-node))
           (cnt 0))
      (declare (fixnum cnt))
      (each-file-line-bytes (bytes beg end filepath)
        (when (zerop (mod (incf cnt) 5000))
          (print (list (dict:count memo) cnt)))
        (let ((in (byte-stream:make bytes :start beg :end end)))
          (declare (dynamic-extent in))
          (values (insert in trie memo))))
      (setf trie (memoize trie memo))
      trie))
  
  (defun member?-impl (in node)
    (declare #.*fastest*)
    (cond ((null node) nil)
          ((= (byte-stream:peek in) (node-label node))
           (or (byte-stream:eos? in)
  