           (RedNode. (.-key app) (.-val app)
                     (RedNode. (.-key left) (.-val left)
                               (.-left left)
-                              (.-left app))
+                              (.-left app)
+                              nil)
                     (RedNode. (.-key right) (.-val right)
                               (.-right app)
-                              (.-right right))
+                              (.-right right)
+                              nil)
                     nil)
           (RedNode. (.-key left) (.-val left)
                     (.-left left)

        (if (coercive-not= t nil)
          (let [c (comp k (.-key t))]
            (cond
              (zero? c)  (PersistentTreeMapSeq. nil (conj stack t) ascending? -1)
              ascending? (if (neg? c)
                           (recur (conj stack t) (.-left t))
                           (recur stack          (.-right t)))

                           (recur (conj stack t) (.-right t))
                           (recur stack          (.-left t)))))
          (if (coercive-= stack nil)
            (PersistentTreeMapSeq. nil stack ascending? -1 nil))))))

  (-entry-key [coll entry] (key entry))

