                        (:started-by :overlapped-by)
                        (difference
                          (assert-proper-head
-                           (cons (narrow x (t/end y) (t/end x)) (next xs)))
+                           (cons (slice x (t/end y) (t/end x)) (next xs)))
                          (assert-proper-head (next ys)))
 
                        :finished-by
-                       (cons (narrow x (t/beginning x) (t/beginning y))
+                       (cons (slice x (t/beginning x) (t/beginning y))
                              (difference
                                (assert-proper-head (next xs))
                                (assert-proper-head (next ys))))
 
                        :overlaps
-                       (cons (narrow x (t/beginning x) (t/beginning y))
+                       (cons (slice x (t/beginning x) (t/beginning y))
                              (difference
                                (assert-proper-head (next xs))
                                ys))
 
                        :contains
-                       (cons (narrow x (t/beginning x) (t/beginning y))
+                       (cons (slice x (t/beginning x) (t/beginning y))
                              (difference
                                (assert-proper-head
-                                 (cons (narrow x (t/end y) (t/end x)) (next xs)))
+                                 (cons (slice x (t/end y) (t/end x)) (next xs)))
                                (assert-proper-head (next ys))))))
                    ;; If xs but no ys
                    xs)

            (recur
              (next intervals)
              (next groups)
              (assoc result group [(narrow ival (t/beginning group) (t/end group))])
              [])

            (:overlaps)

;;             (:finishes :during :equals) (recur (next xs) (next ys) result)
;;             :starts (recur (next xs) ys result)
;;             (:started-by :overlapped-by)
;;             (recur (cons (slice x (t/end y) (t/end x)) (next xs)) (next ys) result)
;;             :finished-by (recur (next xs) (next ys) (clojure.core/conj result (slice x (t/beginning x) (t/beginning y))))
;;            :overlaps (recur (next xs) ys (clojure.core/conj result (slice x (t/beginning x) (t/beginning y))))
;;            :contains
             #_(recur (cons (slice x (t/end y) (t/end x)) (next xs))
                    (next ys)
                    (clojure.core/conj result (slice x (t/beginning x) (t/beginning y))))))
         (apply clojure.core/conj result xs))
       result)))
  ([s1 s2 & sets]
