anchor.diff:      (unless (byte-stream:eos? in)
         (push-child (byte-stream:eat in) new-node))))
   
  -(defun insert (in parent)
  +(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)))
  -        (push-child in parent)
  -      (insert (byte-stream:eat in) 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)
  
positive.code:   (label     0 :type octet)
    (sibling nil :type (or null node))
    (child   nil :type (or null node))
    (hash     -1 :type fixnum))
  
  (defun push-child (in parent)
    (declare #.*fastest*) 
  
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)))
  