                 (swap! elems (fn [elems] (drop-while #(key-lt (nth % 0) (nth movement 1)) elems)))
                 (first (first @elems)))))))
 
-(defn run-iterator-prop [min-keys actions movements]
-  (let [tree (apply-to-tree (tree min-keys) actions)
+(defn run-iterator-prop [min-keys key-len actions movements]
+  (let [tree (apply-to-tree (tree min-keys key-len) actions)
         sorted-map (apply-to-sorted-map (sorted-map-by compare-keys) actions)
-        iterator-resukey-lts (apply-to-iterator (iterator tree) movements)
-        elems-resukey-lts (apply-to-elems (seq sorted-map) movements)]
+        iterator-results (apply-to-iterator (iterator tree) movements)
+        elems-results (apply-to-elems (seq sorted-map) movements)]
     #_(.pretty-print tree)
-    (= iterator-resukey-lts elems-resukey-lts)))
-
-(def iterator-prop
+    (= iterator-results elems-results)))
+
+(defn iterator-prop [key-len]
   (prop/for-all [min-keys gen/s-pos-int
-                 actions (gen/vector gen-action)
-                 movements (gen/vector gen-movement)]
-                (run-iterator-prop min-keys actions movements)))
-
-(defn run-intersection-prop [min-keys actionss movements]
-  (let [trees (map #(apply-to-tree (tree min-keys) %) actionss)
+                 actions (gen/vector (gen-action key-len))
+                 movements (gen/vector (gen-movement key-len))]
+                (run-iterator-prop min-keys key-len actions movements)))
+
+(defn run-intersection-prop [min-keys key-len actionss movements]
+  (let [trees (map #(apply-to-tree (tree min-keys key-len) %) actionss)
         elems (apply clojure.set/intersection (map #(set (map vec %)) trees))
         sorted-map (into (sorted-map-by compare-keys) elems)
-        iterator-resukey-lts (apply-to-iterator (intersection (into-array (map iterator trees))) movements)
-        elems-resukey-lts (apply-to-elems (seq sorted-map) movements)]
-    (= iterator-resukey-lts elems-resukey-lts)))
-
-(def intersection-prop
+        iterator-results (apply-to-iterator (intersection (into-array (map iterator trees))) movements)
+        elems-results (apply-to-elems (seq sorted-map) movements)]
+    (= iterator-results elems-results)))
+
+(defn intersection-prop [key-len]
   (prop/for-all [min-keys gen/s-pos-int
-                 actionss (gen/not-empty (gen/vector (gen/vector gen-action)))
-                 movements (gen/vector gen-movement)]
-                (run-intersection-prop min-keys actionss movements)))
-
+                 actionss (gen/not-empty (gen/vector (gen/vector (gen-action key-len))))
+                 movements (gen/vector (gen-movement key-len))]
+                false))
 (comment
-  (dc/quick-check 1000 least-prop)
-  (dc/quick-check 1000 greatest-prop)
-  (dc/quick-check 1000 equality-prop)
-  (dc/quick-check 1000 reflexive-prop)
-  (dc/quick-check 1000 transitive-prop)
-  (dc/quick-check 1000 anti-symmetric-prop)
-  (dc/quick-check 1000 total-prop)
+  (dc/quick-check 1000 (least-prop 1))
+  (dc/quick-check 1000 (least-prop 2))
+  (dc/quick-check 1000 (greatest-prop 1))
+  (dc/quick-check 1000 (greatest-prop 2))
+  (dc/quick-check 1000 (equality-prop 1))
+  (dc/quick-check 1000 (equality-prop 2))
+  (dc/quick-check 1000 (reflexive-prop 1))
+  (dc/quick-check 1000 (reflexive-prop 2))
+  (dc/quick-check 1000 (transitive-prop 1))
+  (dc/quick-check 1000 (transitive-prop 2))
+  (dc/quick-check 1000 (anti-symmetric-prop 1))
+  (dc/quick-check 1000 (anti-symmetric-prop 2))
+  (dc/quick-check 1000 (total-prop 1))
+  (dc/quick-check 1000 (total-prop 2))
   (dc/quick-check 1000 (building-prop gen-assoc))
   (dc/quick-check 10000 (building-prop gen-action))
   ;; cljs.core.pr_str(cemerick.double_check.quick_check(1000, aurora.btree.building_prop(aurora.btree.gen_action)))

  (maintain! [this max-keys]
             (assert max-keys)
             (when-not (nil? parent)
               ;; TODO update ranges (.update-lower this)
               (let [min-keys (js/Math.floor (/ max-keys 2))]
                 (when-not (nil? children)
                   (dotimes [ix (alength children)]

                    (recur (mapcat #(.-children %) nodes)))))
  ISeqable
  (-seq [this]
        (let [result #js []]
          (.into this result)
          (seq result))))

(deftype Node [parent parent-ix keys vals children ^:mutable lower ^:mutable upper]
  Object
  (into [this result]
        (dotimes [ix (alength keys)]
          (when-not (nil? children)
            (.into (aget children ix) result))
          (apush result #js [(aget keys ix) (aget vals ix)]))
        (when-not (nil? children)
          (.into (aget children (alength keys)) result)))
  (seek [this key ix]
        (loop [lo (if (> ix 0) ix 0)
               hi (- (alength keys) 1)]
