     (lazy-seq (cons start (o-range ds i j (walk ds start i j) end)))))
 
 (defn- liftable? [ds [A B C D]]
-  (let [r (o-range ds 0 1 A C)
-        s (map #(walk ds % 3 1) r)
-        t (filter #{B D} s)
-        u (count t)]
-    (println [A B C D] r s t u)
-    (not= 1 u)))
+  (->> (o-range ds 0 1 A C) (map #(walk ds % 3 1)) (filter #{B D}) count
+    (not= 1)))
 
 (defn- kf-complexity [ds]
   (reduce + (for [D (orbit-reps ds [0 1 3])] (- (r ds 0 1 D) 2))))

(defn pinch-first-local-2-cut [ds]
  (if-let [[A B C D] (first (filter (partial liftable? ds) (local-2-cuts ds)))]
    (let [[ds E1] (cut-face ds A C)
          [ds E2] (cut-face ds D B)]
      (merge-volumes (pinch-tile ds E1 E2)))
    ds))

(defn simplified [ds]

                             [i (into {} (for [D (orbit-reps t [i j])
                                               E (orbit-elements t [i j] D)]
                                           [E 1]))]))]
          [(make-dsymbol (dim t) (size t) ops* vs*) d*])))

(defn- o-range [ds i j start end]
  (if (= start end)
