    ;:autoconstructive-entropy 0.1
    })
 
+


(def penn-atom-generators
  (cycle-to-longest (concat (distinct (mapv :target (:all-train @penn-fitness-cases))) ;; classes, for output
                            (list (tag-instruction-erc [:exec :integer :float :boolean :string] 1000)
                                  (tagged-instruction-erc 1000)
                                  (fn [] (lrand-int 1000))
                                  (fn [] (lrand 1))))
                    (for [n (map inc 
                                 (range (count (:inputs (first (:train @penn-fitness-cases))))))]
                      (symbol (str "in" n)))
                    (concat (registered-for-stacks [:exec :integer :float :boolean])
                            '(string_pop string_dup string_dup_times string_dup_items
                                         string_swap string_rot string_flush string_eq string_stackdepth
                                         string_yank string_yankdup string_shove string_empty))))

  (let [raw-data (read-data)
        target-column (.indexOf (mapv clojure.string/upper-case (mapv name (first raw-data)))
                                "CLASS")
        vocabulary (sort (distinct (flatten (rest raw-data))))
        inputs (fn [row] 
                 (let [raw-inputs (concat (take target-column row) 
                                          (drop (inc target-column) row))]
                   (vec (flatten (for [i raw-inputs]
                                   (map #(= i %) vocabulary)))))) ;; inputs are boolean
        target (fn [row] (str (nth row target-column))) ;; target classes are strings
        fitness-cases-shuffled (lshuffle (mapv (fn [row]
                                                 {:inputs (inputs row)
