                       (set! node (aget (.-children node) ix))
                       (set! ix 0)
                       (recur))
-                    (if (or (and (identical? node start-node) (== ix start-ix))
-                            (key= key (aget (.-keys node) ix))
-                            (nil? (.-children node))
-                            (key-lt (.-upper (aget (.-children node) ix)) key))
-                      nil
-                      (do
-                        (set! node (aget (.-children node) ix))
-                        (set! ix 0)
-                        (recur))))))))))
+                    (if (key= key (aget (.-keys node) ix))
+                      true
+                      (if (or (and (identical? node start-node) (== ix start-ix))
+                              (nil? (.-children node))
+                              (key-lt (.-upper (aget (.-children node) ix)) key))
+                        false
+                        (do
+                          (set! node (aget (.-children node) ix))
+                          (set! ix 0)
+                          (recur)))))))))))
   (undo [this]
         (set! node old-node)
         (set! ix old-ix)

      (case (nth movement 0)
        :next (do
                (swap! elems rest)
                (first (first @elems)))
        :seek (do
                (swap! elems (fn [elems] (drop-while #(key-lt (nth % 0) (nth movement 1)) elems)))
                (first (first @elems)))))))

(defn run-iterator-prop [min-keys key-len actions movements]
  (let [tree (apply-to-tree (tree min-keys key-len) actions)

        (set! old-node node)
        (set! old-ix ix)
        (set! old-end? end?)
        (if (true? end?)
          false
          (if (nil? (.-children node))
            (do
              (set! ix (+ ix 1))
