      (doseq [[tree movements] benches]
        (apply-to-iterator (iterator tree) movements))))
 
-  (let [tree1 (tree 10)
-        _ (dotimes [i 10000]
-            (let [i (+ i 0)]
-              (.assoc! tree1 #js [i (+ i 1) (+ i 2)] (* 2 i))))
-        tree2 (tree 10)
-        _ (dotimes [i 1000]
-            (let [i (+ i 1)]
-              (.assoc! tree2 #js [i (+ i 2)] (* 2 i))))
-        tree3 (tree 10)
-        _ (dotimes [i 100000]
-            (let [i (+ i 2)]
-              (.assoc! tree3 #js [(+ i 1) (+ i 2)] (* 2 i))))
-        ]
-     (let [s (solver 3 #js [(contains (iterator tree1)) (contains (iterator tree2)) (contains (iterator tree3))] #js [#js [0 1 2] #js [0 2] #js [1 2]])]
-       (while (not (nil? (.next s))))))
+   (let [tree1 (tree 10)
+         _ (dotimes [i 10000]
+             (let [i (+ i 0)]
+               (.assoc! tree1 #js [i (+ i 1) (+ i 2)] (* 2 i))))
+         tree2 (tree 10)
+         _ (dotimes [i 1000]
+             (let [i (+ i 1)]
+               (.assoc! tree2 #js [i (+ i 2)] (* 2 i))))
+         tree3 (tree 10)
+         _ (dotimes [i 100000]
+             (let [i (+ i 2)]
+               (.assoc! tree3 #js [(+ i 1) (+ i 2)] (* 2 i))))
+         ]
+     (perf-time
+      (let [s (solver 3 #js [(contains (iterator tree1)) (contains (iterator tree2)) (contains (iterator tree3))] #js [#js [0 1 2] #js [0 2] #js [1 2]])]
+        (while (not (nil? (.next s)))))))
 
   (let [tree1 (tree 10)
           _ (dotimes [i 100000]

  )

 )

(enable-console-print!)

(let [tree1 (tree 10 3)
      _ (dotimes [i 10]
          (.assoc! tree1 #js [i i i]))
      tree2 (tree 10 2)
      _ (dotimes [i 10]
          (.assoc! tree2 #js [i i]))
      tree3 (tree 10 2)
      _ (dotimes [i 10]
          (.assoc! tree3 #js [i i]))
      s (solver 3
                #js [(contains (iterator tree1))
                     (contains (iterator tree2))
                     (contains (iterator tree3))]
                #js [#js [0 1 2]
                     #js [0 2]
                     #js [1 2]])
      ]
  (perf-time
   (dotimes [i 2]
     (.next s)
     )))

                    (do
                      (.split this current)
                      (recur 0 (- (alength constraints) 1))))
                  (recur (mod (+ current 1) (alength constraints)) last-changed)))))))
  (all [this]
       (let [results #js []]
         (loop []
           (let [result (.next this)]
             (when-not (nil? result)
               (apush results result)
               (recur))))
         results))
  ISeqable
  (-seq [this]
        (seq (.all this))))

(defn solver [num-vars constraints constraint->ixes]
  (let [constraint->los (amake [i (alength constraint->ixes)]
