 
 (defn solve-quad
   [a b c]
+  (prn a b c)
   (let [t1 (- 0 b)
         t2 (Math/sqrt (- (* b b) (* 4 a c)))
         t3 (* 2 a)

  [events]
  (fn
    [coll t]
    (let [pairs (get events t)]
      (reduce
        (fn
          [c [v1 v2]]
          (if (and (contains? coll v1) (contains? coll v2))
            (disj c v1 v2)
            c))
        coll
        pairs))))

(defn part-2
  []
  (as-> vectors $
    (for [v1 $]
      (let [intersects (for [v2 $
                             :when (not= v1 v2)]
                         [v2 (intersections v1 v2)])]
        [v1 (remove (comp empty? second) intersects)]))
    (map-indexed vector $)
    (for [[i [v1 its]] $]
      (do
        (prn "i:" i " of:" (count $))
        (doseq [[v2 t] its]
          (println "v1:" v1 " intersects with v2:" v2 " at: " t))
        [v1 its]))
    (reduce
      (fn
        [e1 [v1 its]]
        (reduce
          (fn [e2 [v2 ts]]
            (reduce
              (fn [e3 t]
                (update e3 t conj [v1 v2]))
              e2
              ts))
          e1
          its))
      {}
      $)
    (let [events $]
      (reduce
        (simulate events)
        (set vectors)
        (->>
          events
          keys
          sort
          (filter integer?))))))

(defn -main
  "I don't do a whole lot ... yet."

              (->>
                (map - (->d v1 i) (->d v2 i))
                reverse))
        solve-quad' (fn
                      [a b c]
                      (solve-quad (/ a 2) b c))
        rs (for [d dms]
             (->>
               d
               (apply solve-quad')
               #_(map
                 #(if (contains? #{nil :*} %) % (Math/round (double %))))
               set))
        rs-matter (remove #(contains? % :*) rs)]
    (prn rs)
    (if (empty? rs-matter)
      #{:*}
      (apply clojure.set/intersection rs-matter))))
