                     (range (inc dest-layer) src-layer))
                (map (partial Edge->Segment pred)
                     (range (dec dest-layer) src-layer -1)))]
-    (conj (into [] segs) src)))
+    (conj (vec segs) src)))
 
 
 (defn blockify-layer

           succs {}
           preds {}]
      (if (empty? bs)
        (let [block-set (into #{} (vals blocks))
              simple-succs (->> (map (fn [[src edges]]
                                       [src (into #{} (map :dest edges))])
                                     succs)
                                (into {}))
              all-succs (into #{} (reduce set/union (vals simple-succs)))
              long-block (first (filter #(> (count %) 1) block-set))
              layer-id-compare (if (< (-> long-block first :layer-id)
                                      (-> long-block second :layer-id))

          (map->ClassGraph {:classes topo-classes :succs succs
                            :preds preds :sources sources}))
        (let [class (first cs)
              class-set (set class)
              block-succs (->> (mapcat #(-> block-graph :succs (get %)) class)
                               (remove #(contains? class-set (:dest %)))
                               set)
              block-preds (map rev block-succs)
              ss (reduce edge->set succs block-succs)
              ps (reduce edge->set preds block-preds)]
