 ; Define the argmap
 (def argmap
  {:error-function (make-camel-case-error-function-from-cases (first camel-case-train-and-test-cases)
-                                                                     (second camel-case-train-and-test-cases))
+                                                             (second camel-case-train-and-test-cases))
   :atom-generators camel-case-atom-generators
   :max-points 2000
   :max-genome-size-in-initial-program 250

                                                    [])]
                       (let [final-state (run-push (:program individual)
                                                   (->> (make-push-state)
                                                     (push-item input :input)
                                                     (push-item "" :output)))
                             result (stack-ref :output 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

        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.
   Note that 2/3 of spaces/dashes are dashes."
  [len]
  (loop [result-string (word-generator)]
    (if (>= (count result-string) len)
      (cleanup-length result-string len)
      (recur (str result-string
                  (if (< (lrand) 0.66) \- \space)
                  (word-generator))))))

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