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

                  (aset outer-key (aget inner->outer inner-ix) (aget new-key inner-ix))))))
  (reset [this]
         (.reset iterator)
         (.maintain this))
  (key [this]
       outer-key)

               (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))))
                     (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))))

