 
 ;; perf
 
-(def test-matrix [:target    { ;; "sorted-set" (sorted-set)
+(def test-matrix [:target    { "sorted-set" (sorted-set)
                                "btset"      (btset)}
-                  ;; :distinct? [true false]
-;;                   :size    [100 500 1000 2000 5000 10000 20000 50000]
-                  :size      [100 500 20000]
+;;                   :distinct? [true false]
+                  :size    [100 500 1000 2000 5000 10000 20000 50000]
+;;                   :size      [100 500 20000]
                   :method    { "conj"    (fn [opts] (into (:target opts) (:range opts)))
-;;                                "lookup"  (fn [opts] (contains? (:set opts) (rand-int (:size opts))))
-;;                                "iterate" (fn [opts] (doseq [x (:set opts)] (+ 1 x)))
+                               "disj"    (fn [opts] (reduce disj (:set opts) (shuffle (:range opts))))
+                               "lookup"  (fn [opts] (contains? (:set opts) (rand-int (:size opts))))
+                               "iterate" (fn [opts] (doseq [x (:set opts)] (+ 1 x)))
                              }])
 
 (defn test-setup [opts]

         path  empty-path
         level (.-shift set)]
    (if (== 0 level)
      (path-set path level (lookup-leaf (.-keys node) key))
      (let [idx (lookup-node (.-keys node) key)]
        (recur (aget (.-pointers node) idx)
               (path-set path level idx)
               (- level level-shift))))))

          ps (merge-n-split pointers (.-pointers next))]
      (return-array (Node. (aget ks 0) (aget ps 0))
                    (Node. (aget ks 1) (aget ps 1)))))

  (lookup [_ key]
    (let [idx (lookup-range keys key)]
      (when-not (== -1 idx)
        (.lookup (aget pointers idx) key))))
  
  (conj [this key]
    (let [idx   (lookup-insert-node keys key)
          nodes (.conj (aget pointers idx) key)]
      (when nodes
        (let [new-keys     (check-n-splice keys     idx (inc idx) (.map nodes lim-key))
              new-pointers (splice         pointers idx (inc idx) nodes)]
          (if (<= (alength new-pointers) max-len)
            ;; ok as is
            #js [(Node. new-keys new-pointers)]
            ;; gotta split it up
            (let [middle  (half (alength new-pointers))]
              #js [(Node. (cut new-keys     0 middle)
                          (cut new-pointers 0 middle))
                   (Node. (cut new-keys     middle)
                          (cut new-pointers middle))]))))))

  (disj [this key root? left right]
    (let [idx (lookup-range keys key)]
      (when-not (== -1 idx) ;; short-circuit, key not here
        (let [child       (aget pointers idx)
              left-child  (when (>= (dec idx) 0)                 (aget pointers (dec idx)))
