                         (set! ix 0)
                         (recur))
                       (if (or (and (identical? node start-node) (== ix start-ix))
-                              (== key (aget (.-keys node) ix))
+                              (key= key (aget (.-keys node) ix))
                               (nil? (.-children node))
                               (let [lower (.-upper (aget (.-children node) ix))]
                                 (key-lt lower key)))

            (loop [current current]
              (let [max-key (.key (aget iterators (mod (- current 1) (alength iterators))))
                    min-key (.key (aget iterators current))]
                (when-not (== min-key max-key)
                  (.seek (aget iterators current))
                  (if (.-end? (aget iterators current))
                    (set! end? true)

  (toString [this]
            (pr-str (into {} (map vec (seq this)))))
  (assoc! [this key val]
          (.assoc! root key val max-keys))
  (dissoc! [this key]
           (.dissoc! root key max-keys))
  (push! [this ix key&val&child which-child]
           (let [left-child (if (== which-child left-child) (aget key&val&child 2) root)
