anchor.diff:  
   ;;;; Scratch ------------------------------------------------------------------
   (with-zdd
  -  (enumerate (gcprint (draw (zdd-union (zdd-family '(1 2 4) '(3 4))
  -                                       (zdd-set '(1 2)))))))
  +  (enumerate (zdd-union (zdd-set '(1 2))
  +                        (zdd-set '(1 2))
  +                        (zdd-set '(1))
  +                        (zdd-family '(2) '(1 2) '(3))
  +                        )))
   
   (with-zdd
     (enumerate (zdd-intersection (zdd-family '(1) '(1 2) '(3) )
  -                               (zdd-family '(2 3 4) '(1 4) nil '(1 2)))))
  +                               (zdd-family '(2 3 4) '(1 4) nil '(1 2))
  +                               (zdd-family nil '(1 2))
  +                               )))
  
positive.code:   (make-set elements))
  
  
  (defun zdd-union (a b)
    (ematch* (a b)
      (((node) (leaf)) (zdd-union b a))
  
      (((leaf nil) b) b)
      (((leaf t) b) (unit-patch b))
  
negative.code:     (((node var-a hi-a lo-a)
        (node var-b hi-b lo-b))
       (cond
         ((< var-a var-b) (zdd-node var-a hi-a (zdd-union% lo-a b)))
         ((> var-a var-b) (zdd-node var-b hi-b (zdd-union% lo-b a)))
         ((= var-a var-b) (zdd-node var-a
                                    (zdd-union% hi-a hi-b)
                                    (zdd-union% lo-a lo-b)))))))
  (defun zdd-union (&rest zdds)
    (if zdds
      (reduce #'zdd-union% zdds)
      (leaf nil)))
  
  (defun zdd-intersection% (a b)
    (ematch* (a b)
      (((node) (leaf)) (zdd-intersection% b a))
  
      (((leaf nil) _) (leaf nil))
      ((_ (leaf nil)) (leaf nil))
  
      (((leaf t) (leaf _)) b)
      (((leaf t) (node _ _ lo)) (zdd-intersection% a lo))
  
      (((node var-a hi-a lo-a)
        (node var-b hi-b lo-b))
       (cond
         ((< var-a var-b) (zdd-intersection% lo-a b))
         ((> var-a var-b) (zdd-intersection% lo-b a))
         ((= var-a var-b) (zdd-node var-a
                                    (zdd-intersection% hi-a hi-b)
                                    (zdd-intersection% lo-a lo-b)))))))
  
  (defun zdd-intersection (&rest zdds)
    (if zdds
      (reduce #'zdd-intersection% zdds)
      (leaf nil)))
  
  
  (defun zdd-family (&rest sets)
  