anchor.diff:    (label         0 :type octet)
     (terminal?   nil :type boolean)
     (child       nil :type (or null node))
  +  (nobranch-child-labels nil :type list)
     (sibling     nil :type (or null node))
     (child-total   0 :type positive-fixnum) ; amount of child side nodes
     (sibling-total 0 :type positive-fixnum) ; amount of sibling side nodes
  
positive.code:       (when (= -1 hash)
          (setf hash (logxor (sxhash (node-label node))
                             (sxhash (node-terminal? node))
                             (fixnumize (* (sxhash-node (node-child node)) 7))
                             (fixnumize (* (sxhash-node (node-sibling node)) 13))))
          (setf child-total (calc-child-total node)
  
negative.code: 
  ;;;;;;;;;;;;;;;;;;
  ;;; build function
  (defun reduce-nobranch-descendant (node)
    (loop FOR child = (node-child node)
          WHILE (and child
                     (not (node-terminal? child))
                     (not (node-sibling child)))
      COLLECT (node-label child) INTO labels
      DO (setf (node-child node) (node-child child))
      FINALLY
      (setf (node-nobranch-child-labels node) labels)))
  
  (defun share (node memo)
    (when (null node)
      (return-from share nil))
  
    (reduce-nobranch-descendant node)
  
    (or (dict:get node memo)
        (progn 
          (setf (node-child node) (share (node-child node) memo)
                (node-sibling node) (share (node-sibling node) memo))
          (dict:get node memo))
        (setf (dict:get node memo) node)))
  
  (defun push-child (in parent)
    (if (stream:eos? in)
  