                                                     [])]
                        (let [final-state (run-push (:program individual)
                                                    (->> (make-push-state)
-                                                     (push-item input :input)
-                                                     (push-item "" :output)))
-                             result (stack-ref :output 0 final-state)]
+                                                        (push-item input :input)))
+                             result (stack-ref :string 0 final-state)]
                          (when print-outputs
                            (println (format "\n| Correct output: %s\n| Program output: %s" (pr-str correct-output) (pr-str result))))
                          ; Record the behavior

;; random element of the set.
(def camel-case-data-domains
  [[(list ""
          "oneword"
          "two-words"
          "two-words and-a-space"
          "all separate words"
          "all-one-word-with-th-dash"
          "saaaaaaaaaaaaaaaaaaaaaame") 7 0] ;; "Special" inputs covering some base cases
   [(fn [] (camel-case-input (inc (lrand-int 20)))) 193 2000]
   ])

;;Can make Camel Case test data like this:
;(test-and-train-data-from-domains camel-case-data-domains)

; Helper function for error function
(defn camel-case-test-cases

        clojure.math.numeric-tower)
    (:require [clojure.string :as str]))

(defn word-generator
  "Generates words at a nice distribution for Camel Case
   All words will have length [1, 5]."
  []
  (let [chars-between #(map char (range (int %1) (inc (int %2))))
        chars (chars-between \a \z)
        word-len (inc (rand-int 5))]
    (apply str (repeatedly word-len #(rand-nth chars)))))

(defn cleanup-length
  [string len]
  (let [result (take len string)]
    (if (or (= (last result) \space)
            (= (last result) \-))
      (apply str (butlast result))
      (apply str result))))

;; Define test cases
(defn camel-case-input
  "Makes a Camel Case input of length len."
  [len]
  (loop [result-string (word-generator)]
    (if (>= (count result-string) len)
      (cleanup-length result-string len)
      (recur (str result-string
                  (if (< (lrand) 0.5) \- \space)
                  (word-generator))))))

; Atom generators
(def camel-case-atom-generators
