   (if (empty? xs) ()
       (let [n (or n 1)
             choices (map choice (take n xs))]
-        (concat (map second choices)
-                (stagger (concat (remove is-empty-set (map first choices))
-                                 (drop n xs))
-                         (inc n))))))
+        (lazy-seq
+         (concat (map second choices)
+                 (stagger (concat (remove is-empty-set (map first choices))
+                                  (drop n xs))
+                          (inc n)))))))
 
 (defn staggered-union [xs]
   (lazy-seq

   :else (if (empty? x)
           [0 0]
           (let [elt (first x)]
             [(rest x) elt]))))

(defn is-empty-set [x]
  (cond

        coll' (take limit coll)]
    (map #(normalize (select-by-bits % coll')) (range 0 (bit-shift-left 1 (count coll'))))))

(def large-set-cutoff 40)

(defn shrink-if-possible [x]
  (println "entering shrink-if-possible")
  (cond (number? x) x
        (set?    x) x
        :else (let [z (take (inc large-set-cutoff) x)]
