anchor.diff:  
   
   ;;;; Scratch ------------------------------------------------------------------
  -(let ((*draw-unique-sinks* nil))
  -  (with-zdd
  -    (-<> (zdd-join (zdd-family '(1 2) '(7 8) '())
  -                   (zdd-family '(1 5 9) nil)
  -                   (zdd-set '(1)))
  -      (print-through #'enumerate <>)
  -      (zdd-keep-avoiders-of <> '(2 7))
  -      (print-through #'enumerate <>)
  -      (draw <>)
  -      (zdd-size <>)
  -      )))
  +(with-zdd
  +  (-<> (zdd-join (zdd-family '(1 2) '(7 8) '())
  +                 (zdd-family '(1 5 9) nil)
  +                 (zdd-set '(1)))
  +    (print-through #'enumerate <>)
  +    (zdd-keep-avoiders-of <> '(2 7))
  +    (print-through #'enumerate <>)
  +    (draw <>)
  +    (zdd-size <>)
  +    ))
  +
   
   (defparameter *rules* '(
                           (1001 (not 2) 1)
  
positive.code:     :fillcolor "#fafafa"
      :color "#aaaaaa"
      :fontsize 22
      :width 0.05
      ))
  
  (defmethod cl-dot:graph-object-node ((graph (eql 'zdd))
                                       (object cons))
    (make-instance 'cl-dot:node
      :attributes (ematch (car object) ((sink c) (sink-attrs c)))))
  
  (defmethod cl-dot:graph-object-node ((graph (eql 'zdd))
                                       (object leaf))
    (make-instance 'cl-dot:node
      :attributes (ematch object ((sink c) (sink-attrs c)))))
  
  (defun wrap-node (object)
    (if *draw-unique-sinks*
      object
      (ematch object
        ((sink) (cons object nil))
        ((node) object))))
  
  (defmethod cl-dot:graph-object-points-to ((graph (eql 'zdd))
                                            (object t))
    (ematch object
      ((sink _) '())
      ((cons (sink) _) '())
      ((node _ hi lo)
       (list (attrs (wrap-node hi) :style :solid)
             (attrs (wrap-node lo) :style :dashed)))))
  
  (defun draw (zdd &optional (filename "zdd.png"))
    (cl-dot:dot-graph
      (cl-dot:generate-graph-from-roots 'zdd (list (wrap-node zdd)))
      filename
      :format :png)
    zdd)
  
  
  
negative.code:                         )
    )
  
  (with-zdd
    (-<> (make-rule-tree *rules*)
      ; (print-enumerated <>)
      ; (zdd-keep-avoiders-of <> '(2 7))
      (mapprint-through #'enumerate <>)
      (print-through #'zdd-count <>)
      (print-through #'zdd-size <>)
      (draw <> :unique-sinks t :unique-nodes t :hexp (curry #'<= 1000))
      ; (zdd-size <>)
      (never)
      )
    ; (pr '--------------)
    ; (-<> (apply #'zdd-family *state*)
    ;   (mapprint-through #'enumerate <>)
    ;   (print-through #'zdd-count <>)
    ;   (print-through #'zdd-size <>)
    ;   ; (draw <>)
    ;   ; (zdd-size <>)
    ;   (never)
    ;   )
    ; (pr '--------------)
    ; (-<> (apply-rule-tree (apply #'zdd-family *state*)
    ;                       (make-rule-tree *rules*)
    ;                       100)
    ;   (mapprint-through #'enumerate <>)
    ;   (print-through #'zdd-count <>)
    ;   (print-through #'zdd-size <>)
    ;   ; (draw <>)
    ;   ; (zdd-size <>)
    ;   (never)
    ;   )
    )
  
  
  (defun test ()
  