         string-tweak (fn [st]
                        (apply str (map (fn [c]
                                          (if (< (lrand) uniform-mutation-string-char-change-rate)
-                                           (lrand-nth (concat ["\n" "\t"] 
-                                                              (map (comp str char) (range 32 127))))
+                                           (lrand-nth (vec (concat ["\n" "\t"] 
+                                                                   (map (comp str char) 
+                                                                        (range 32 127)))))
                                            c))
                                        st)))
         instruction-mutator (fn [token]

    (recur parent2 parent1 argmap)
    (let [short-genome (:genome parent1)
          long-genome (:genome parent2)
          short-genome-lengthened (concat short-genome
                                          (repeat (- (count long-genome) (count short-genome))
                                                  'uniform-padding))
          new-genome (vec (remove-uniform-padding
                            (mapv (fn [x1 x2]
                                    (if (< (lrand) 0.5)

        string-tweak (fn [st]
                       (apply str (map (fn [c]
                                         (if (< (lrand) uniform-mutation-string-char-change-rate)
                                           (lrand-nth (vec (concat ["\n" "\t"] 
                                                                   (map (comp str char) 
                                                                        (range 32 127)))))
                                           c))
                                       st)))
        constant-mutator (fn [token]
