                (let [iterator (aget iterators i)]
                  (if (false? (.-blocked? iterator))
                    (do
+                     (debug :seeking i (map #(.key %) iterators) (map #(.key (.-iterator %)) iterators))
                      (.splice iterators i 1)
                      (.seek iterator (.key (aget iterators (- (alength iterators) 1))))
-                     (js/goog.array.binaryInsert iterators iterator (fn [i0 i1] (key-compare (.key i0) (.key i1))))
+                     (dotimes [i (alength iterators)]
+                       (aset keys i (.key (aget iterators i))))
+                     (.splice iterators (key-find keys (.key iterator)) 0 iterator)
                      (recur -1))
                    (recur (+ i 1))))
 

              (loop []
                (.-keys node)
                key
                (set! ix (.seek node key 0))
                (if (>= ix (alength (.-keys node)))
                  (if (nil? (.-children node))
                    (do

               (let [min-key (.key (aget iterators 0))
                     max-key (.key (aget iterators (- (alength iterators) 1)))]
                 (if (key= min-key max-key)
                   (if (true? (.-blocked? (aget iterators (- (alength iterators) 1))))
                     (do
                       (set! end? true)
                       (debug :end/found))
                     (debug :found min-key))
                   (recur 0)))

               ;; find the minimum non-blocked iter and seek it
